精华内容
下载资源
问答
  • 外部类可以访问静态内部类的 private 属性。 原因 静态内部类在经过 Java 编译器编译后会生成 private 属性对应的 access$Xxx(),供外部类使用。 一个被使用到的时候才会加载到内存。静态内部类之所以可以延迟加载...

    外部类可以访问静态内部类的 private 属性。

    原因

    静态内部类在经过 Java 编译器编译后会生成 private 属性对应的 access$Xxx(),供外部类使用。

    一个类被使用到的时候才会加载到内存。静态内部类之所以可以延迟加载是因为,外部类通过调用静态内部类的 static 方法(access$Xxx()),也就是会执行 invokestatic 这个字节码从而引起静态内部类加载(这是触发类加载的一种场景)。

    扩展

    可以通过在私有的构造方法中判断对象引用是否为 null 来防止反射调用。

    展开全文
  • java 外部类静态方法访问内部类

    千次阅读 2012-07-11 10:46:48
    public class TestLinkedList { public static void main(String[] args) { TestLinkedList ls = new TestLinkedList();...2. 不能从嵌套类的对象中访问静态的外围类对象。 (Thinking in java
    public class TestLinkedList {
         public static void main(String[] args) {
        	 TestLinkedList ls = new TestLinkedList();
    		List<IntModel> list = new LinkedList<IntModel>();
    		for (int i = 10; i > 0; i--) {
    			list.add(ls.new IntModel(i));
    		}
    	}
         
         class IntModel{
        	 int i = 1;
        	 public IntModel(int i){
        		 this.i = i;
        	 }
        	 @Override
        	 public String toString() {
        		return Integer.toString(i);
        	 }
        }
         
    }


     

    看代码中list.add()方法必须初始化外部类自后才可以用new初始化内部类普通的内部类对象隐含地保存了一个引用,指向创建它的外围类对象。

    所以要在static方法(类加载时已经初始化)调用内部类的必须先创建外部类。

    下面在说下嵌套类:如果你不需要内部类对象与其外围类对象之间有联系,那你可以将内部类声明为static。这通常称为嵌套类(nested class)。想要理解static应用于内部类时的含义,你就必须记住,普通的内部类对象隐含地保存了一个引用,指向创建它的外围类对象。然而,当内部类是static的时,就不是这样了。嵌套类意味着:  

    1. 要创建嵌套类的对象,并不需要其外围类的对象。 

    2. 不能从嵌套类的对象中访问非静态的外围类对象。

    (Thinking in java)

    展开全文
  • (1) 与一般内部类不同,在静态代码中不能够使用this操作,所以在静态内部类中只可以访问外部类的静态变量和静态方法。使用静态内部类的目的和使用内部类相同。如果一个内部类不依赖于其外部类的...因为内部静态类

    (1) 与一般内部类不同,在静态代码中不能够使用this操作,所以在静态内部类中只可以访问外部类的静态变量和静态方法。使用静态内部类的目的和使用内部类相同。如果一个内部类不依赖于其外部类的实例变量,或与实例变量无关,则选择应用静态内部类。

    (2)  因为非静态内部类只能声明非静态成员或方法,而静态内部类则可拥有静态的成员和方法。 但静态内部类中只能引用其外部类的静态成员或变量。因为内部静态类并不与外部类对象关联。    此外,内部类的继承与接口与外部类独立,解决了多继承的问题。


    内部类的作用:

    1、隐藏你不想让别人知道的操作,也即封装性。

    2、一个内部类对象可以访问创建它的外部类对象的内容,甚至包括私有变量!


    内部类的功能在于,每个内部类都能独立的继承一个接口的实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。内部类使得多重继承的解决方案变得完整,并且内部类允许继承多个非接口类型(类或抽象类)。通过内部类分别继承一个基类,外部类创建内部类的对象,并使用内部类的方法,变相地实现了多继承。
    java内部类有什么好处?为什么需要内部类?
    1、举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直接实现这个接口的功能。

    2、真正的原因是这样的,java中的内部类和接口加在一起,可以解决常被C++程序员抱怨java中存在的一个问题:没有多继承。实际上,C++的多继承设计起来很复杂,而java通过内部类加上接口,可以很好的实现多继承的效果。

    静态内部类和非静态内部类的区别
    1、和非静态内部类相比,区别就在于静态内部类没有了指向外部的引用。
    2、在任何非静态内部类中,都不能有静态数据、静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。


    展开全文
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部类外部创建非静态内部类2.2 在外部类外部创建静态内部类2.3 在外部类内部创建内部类语法3 内部类的分类3.1 成员内部类3.2 静态...

    1. 内部类的基本概念

    1.1 内部类的定义

    内部类: 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。

    class Outer{
        private String str ="外部类中的字符串";
        //************************** 
        //定义一个内部类
        class Inner{
            private String inStr= "内部类中的字符串";
            //定义一个普通方法
            public void print(){
                //调用外部类的str属性
                System.out.println(str);
            }
        }
        //************************** 
        //在外部类中定义一个方法,该方法负责产生内部类对象并调用print()方法
        public void fun(){
            //内部类对象
            Inner in = new Inner();
            //内部类对象提供的print
            in.print();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            //创建外部类对象
            Outer out = new Outer();
            //外部类方法
            out.fun();
        }
    }
    

    运行结果:外部类中的字符串
    但是如果去掉内部类:

    class Outer{
        private String outStr ="Outer中的字符串";
        public String getOutStr()
        {
            return outStr;
        }
        public void fun(){  //2
            //this表示当前对象
            Inner in = new Inner(this); //3
            in.print();                 //5
        }
    }
    class Inner{
        private String inStr= "Inner中的字符串";
        private Outer out;
        //构造注入
        public Inner(Outer out)  //3
        {
            this.out=out;       //4.为Inner中的out变量初始化
        }
        public void print(){    //6
            System.out.println(out.getOutStr()); //7
        }
    } 
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();  //1.
            out.fun(); //2.
        }
    }
    

    执行结果:Outer中的字符串
    但是去掉内部类之后发现程序更加难以理解。

    1.2 内部类的优缺点

    内部类的优点:

    1. 内部类与外部类可以方便的访问彼此的私有域(包括私有方法、私有属性)。
    2. 内部类是另外一种封装,对外部的其他类隐藏。
    3. 内部类可以实现java的单继承局限。

    内部类的缺点:

    结构复杂。
    记录:使用内部类实现多继承:

    class A {
        private String name = "A类的私有域";
        public String getName() {
            return name;
        }
    }
    class B {
        private int age = 20;
        public int getAge() {
            return age;
        }
    }
    class Outter {
        private class InnerClassA extends A {
            public String name() {
                return super.getName();
        }
    }
        private class InnerClassB extends B {
            public int age() {
                return super.getAge();
        }
    }
        public String name() {
            return new InnerClassA().name();
        }
        public int age() {
            return new InnerClassB().age();
        }
    }
    public class Test2 {
            public static void main(String[] args) {
                Outter outter = new Outter();
                System.out.println(outter.name());
                System.out.println(outter.age());
            }
    }
    

    在这里插入图片描述

    2. 创建内部类

    2.1 在外部类外部 创建非静态内部类

    语法: 外部类.内部类 内部类对象 = new 外部类().new 内部类();
    举例: Outer.Inner in = new Outer().new Inner();

    2.2 在外部类外部 创建静态内部类

    语法: 外部类.内部类 内部类对象 = new 外部类.内部类();
    举例: Outer.Inner in = new Outer.Inner();

    2.3 在外部类内部创建内部类语法

    在外部类内部创建内部类,就像普通对象一样直接创建:Inner in = new Inner();

    3. 内部类的分类

    在Java中内部类主要分为成员内部类、静态内部类、方法内部类、匿名内部类

    3.1 成员内部类

    类比成员方法

    1. 成员内部类内部不允许存在任何static变量或方法 正如成员方法中不能有任何静态属性 (成员方法与对象相关、静态属性与类有关)
    class Outer {
        private String name = "test";
        public  static int age =20;
    
        class Inner{
            public static int num =10;
            public void fun()
            {
                System.out.println(name);
                System.out.println(age);
            }
        }
    }
    public class Test{
        public static void main(String [] args)
        {}
    }
    

    在这里插入图片描述
    2. 成员内部类是依附外部类的,只有创建了外部类才能创建内部类。

    3.2 静态内部类

      关键字static可以修饰成员变量、方法、代码块、其实还可以修饰内部类,使用static修饰的内部类我们称之为静态内部类,静态内部类和非静态内部类之间存在一个最大的区别,非静态内部类在编译完成之后会隐含的保存着一个引用,该引用是指向创建它的外围类,但是静态类没有。没有这个引用就意味着:
      1.静态内部类的创建不需要依赖外部类可以直接创建。
      2.静态内部类不可以使用任何外部类的非static类(包括属性和方法),但可以存在自己的成员变量。

    class Outer {
        public String name = "test";
        private static int age =20;
    
        static class Inner{
            private String name;
            public void fun()
            {
                System.out.println(name);
                System.out.println(age);
            }
        }
    }
    public class Test{
        public static void main(String [] args)
        {
            Outer.Inner in = new Outer.Inner();
        }
    }
    

    在这里插入图片描述

    3.3 方法内部类

    方法内部类顾名思义就是定义在方法里的类
    1.方法内部类不允许使用访问权限修饰符(public、private、protected)均不允许。

    class Outer{
        private int num =5;
        public void dispaly(final int temp)
        {
            //方法内部类即嵌套在方法里面
            public class Inner{
            }
        }
    }
    public class Test{
        public static void main(String[] args)
        {}
    }
    

    在这里插入图片描述
    2. 方法内部类对外部完全隐藏,除了创建这个类的方法可以访问它以外,其他地方均不能访问 (换句话说其他方法或者类都不知道有这个类的存在)方法内部类对外部完全隐藏,出了创建这个类的方法可以访问它,其他地方均不能访问。
    3. 方法内部类如果想要使用方法形参,该形参必须使用final声明(JDK8形参变为隐式final声明)

    class Outer{
        private int num =5;
        //普通方法
        public void dispaly(int temp)
        {
            //方法内部类即嵌套在方法里面
            class Inner{
                public void fun()
                {
                    System.out.println(num);
                    temp++;
                    System.out.println(temp);
                }
            }
            //方法内部类在方法里面创建
            new Inner().fun();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly(2);
        }
    }
    

    在这里插入图片描述

    3.4 匿名内部类

      匿名内部类就是一个没有名字的方法内部类,因此特点和方法与方法内部类完全一致,除此之外,还有自己的特点:
    1.匿名内部类必须继承一个抽象类或者实现一个接口。
    2.匿名内部类没有类名,因此没有构造方法。

    //匿名内部类
    //声明一个接口
    interface MyInterface {
        //接口中方法没有方法体
        void test();
    }
    class Outer{
        private int num = 5;
        public void dispaly(int temp)
        {
            //匿名内部类,匿名的实现了MyInterface接口
            //隐藏的class声明
            new MyInterface()
            {
                public void test()
                {
                    System.out.println("匿名实现MyInterface接口");
                    System.out.println(temp);
                }
            }.test();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly(3);
        }
    }
    

    在这里插入图片描述

    4. 内部类与外部类的关系

    • 对于非静态的内部类,内部类的创建依赖外部类的实例对象,在没有外部类实例之前是无法创建内部类的。
    • 内部类可以直接访问外部类的元素(包括私有域)—外部类在内部类之前创建,创建内部类时会将外部类的对象传入
    class Outer{
        //成员变量  与对象有关
        private String msg;
        private int age;
        //--------------------------
        class Inner{
            public void dispaly()
            {
                //此处有一个隐藏的Outer.this
                msg = "test";
                age = 20;
                System.out.println(msg);
                System.out.println(age);
            }
        }
        //--------------------------
        public void test()
        {
            Inner in = new Inner();
            in.dispaly();
        }
    }
    public class Test{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.test();
        }
    }
    
    • 外部类可以通过内部类的引用间接访问内部类元素 – -要想访问内部类属性,必须先创建内部类对象
    class Outer{
        public void dispaly()
        {
            //外部类通过创建内部类的对象间接访问内部类元素
            Inner in = new Inner();
            in.dispaly();
        }
        class Inner{
            public void dispaly()
            {
                System.out.println("内部类");
            }
        }
    }
    public class Test1{
        public static void main(String[] args)
        {
            Outer out = new Outer();
            out.dispaly();
        }
    }
    
    • 内部类是一个相对独立的个体,与外部类没有关系。
    展开全文
  • Java外部类外部访问

    千次阅读 2018-11-09 14:29:56
    public class Demo{ ...//1、外部类外部访问成员内部类; &nbsp;&nbsp;Outer out = new Outer();//建立外部类对象 &nbsp;&nbsp;Outer.Inner in = out.new Inner();//根据外部类对象建立内部类对...
  • java外部类内部类的关系

    千次阅读 2018-12-04 21:48:16
    在学习外部类内部类之前我们首先要弄明白private,public,protected,default在访问权限上有什么不同,这对我们之后的理解会有一定的帮助。 1、private:访问权限最低的访问控制符,被它修饰的变量只能访问...
  • 静态内部类不能访问外部类的属性方法,所以android开发过程中可以优化handler 其他内部类可以访问外部类,是因为持有外部类的引用。 成员内部类说明: 成员内部类拥有和外部类同名的成员变量或者方法时,会发生...
  • 我们都知道,外部类对非静态内部类是完全透明的,即非静态内部类可以访问外部类包括private成员在内的所有成员,但是,另一个常常被大家忽略的地方是外部类也可以在类的内部通过新建内部类对象访问静态内部类...
  • Java:内部静态类访问外部类成员的方法 以前不知道内部类的好处,觉得出了使用不方便之外没什么好的,不过在一次无意间参照java主页的一些教程的源代码的时候发现了内部类的真正好处。---内部静态类可以睡意访问...
  • public class Demo1{ &nbsp;public static void main(String []args){ ...//外部类对象.外部类非静态方法 &nbsp;&nbsp;Outer.outer1();//外部类名.外部静态方法&nbsp; &nbsp;} ...
  • Java内部类应用——静态内部类

    千次阅读 2019-06-09 10:25:23
    一点睛 如果使用static来修饰一个内部...二实战——静态内部类不能访问外部类的实例成员,只能访问外部类成员 1点睛 静态内部类可以包含静态成员,也可以包含非静态成员。根据静态成员不能访问静态成员的规...
  • 2,外部类要访问内部类,必须建立内部类对象 访问格式: 当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中 可以直接建立内部类对象, 格式 外部类名.内部类名 变量名 = 外部类对象.内部类对
  • 内部类可以声明public、protected、private等访问限制,可以声明 为abstract的供其他内部类外部类继承与扩展,或者声明为static、final的,也可以实现特定的接口。 外部类按常规的类访问方式使用内部 ,唯一的...
  • 外部类调用非静态内部类的的方法 我们知道,一个内部类里面的方法,是不可以被直接调用的。但是如果我们想使用内部中的方法,我们应该怎么做呢? 第一种办法 public class test{ public static void main...
  • (的编译顺序:外部类静态方法或属性–内部类,如果内部类声明为静态的,造成编译顺序冲突。个人理解) 2、实例化的时候需要依附在外部类上面。比如:B是A的非静态内部类,实例化B,则:A.B b = new A().new B(); ...
  • 深入理解Java中为什么内部类可以访问外部类的成员

    万次阅读 多人点赞 2014-02-26 22:54:26
    内部类简介 虽然Java是一门相对比较简单的...其中一个疑惑就是为什么内部类对象可以访问外部类对象中的成员(包括成员变量和成员方法)? 早就想对内部类这个特性一探究竟了,今天终于抽出时间把它研究了一下。 内
  • 一、什么是嵌套 嵌套是指被定义在另一个内部。嵌套存在的目的应该只是为他的外围提供服务。...最好把他看做是普通,只是碰巧被声明在另一个内部而已,它可以访问外围的所有成...
  • java 匿名 静态内部类 内部类

    千次阅读 2012-04-13 21:55:02
    内部 一个java程序就是一个的集合。 Eg: class EnclosingClass{ ...外部类访问内部类时,必须先创建对象. 2编译之后,内部也可产生单独的.class文件,文件名为:外部类名$内部类名.class Eg 内部使
  • 内部类里,想引用外部类对象,为什么是外部类.this而不是外部类加引用变量,还有.操作应该是成员操作符吧,这样this不就成了外部类成员了
  • Java 内部类分四种:成员内部类、局部内部类静态内部类和匿名内部类
  • 当时只是回答了静态内部类访问外部类静态方法,成员内部类访问外部类的所有方法。然后面试官问我原因我就答不上来了。还是原来看的不仔细,这里具体整理下。 通俗的理解,在一个里面定义另一个,这样的...
  • Java 内部类外部类的关系

    千次阅读 2016-11-23 21:39:06
    内部类分为:非静态内部类、静态类内部类、匿名内部类和局部内部类。  内部类可以直接访问外部类的私有属性,这是由于这个原因。  1、非静态内部类对象会持有外部类的对象。其实是,非静态内部类对象依赖于外部类...
  • (4)外部类不能直接访问所有内部类的成员和方法,但可以通过创建内部类对象的方式进行访问。 (5)外部类和内部类拥有同名的变量和方法时,内部类有需要进行访问外部的同名变量或方法,可以通过外部类.this.方法...
  • 如何创建内部类对象 格式:外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称(); 实例如下: 定义一个包含内部类的外部类: package NeiBuLei; //如果出现了重名现象,那么格式是:外部类名称....
  • java 静态内部类 只有在是静态内部类的情况下才能把static修复符放在前,其他任何时候static都是不能修饰的。  //定义张三这个人 Person p = new Person("张三"); //设置张三的家庭信息 p.setHome...
  • 一般情况,我们把定义成独立的单元。有些情况下,我们把一个放在另一个...而外部顶级(我们以前接触的)只能使用public和default修饰。 注意 内部类只是一个编译时概念,一旦我们编译成功,就会成为完全不...
  • Java静态内部类

    千次阅读 2019-04-18 08:55:07
    Java静态内部类 在java内部类主要分为成员...因此,如果有一个非静态内部类对象那么一定存在对应的外部类对象。 非静态内部类对象单独属于外部类的某个对象 2.非静态内部类可以直接访问外部类的成员,但是...
  • 成员内部类创建对象必须使用外部类对象来创建内部类对象,而不能直接new内部类构造方法的方式创建; //普通成员内部类创建对象,需通过外部类对象进行创建 demo01 de1 = new demo01(); DemoChild2 dc2 = de1.new ...
  • Java中的嵌套内部类静态内部类

    万次阅读 多人点赞 2015-06-14 12:03:20
    嵌套可以分为两种,静态的和非静态的...虽然内部类静态嵌套都属于嵌套,但是二者有本质区别:内部类的实例化对象需要绑定一个外围的实例化对象,而静态嵌套的实例化对象不能也无法绑定外围的实例化对象
  • JAVA 静态内部类用法

    千次阅读 2016-01-27 14:13:12
    Java静态内部类(static class)   在一个中创建另外一个,叫做成员内部类。这个成员内部类可以静态的(利用static关键字修饰),也可以是非静态的。   一、静态内部类的使用目的。 在 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,849
精华内容 45,539
关键字:

java外部类访问内部静态类对象

java 订阅