java内部类

内部类就是定义在一个类内部的类。定义在类中方法间的有两种情况：一种是普通内部类，一种是静态内部类。

 

普通内部类与外部类的关系可以总结为两点：

1.外部类的作用范围内可以任意创建内部类，即使内部类是私有的

2.内部类对象持有对外部类对象的引用，并能访问到外部类的私有属性

即内部类对外部类可见，外部类对内部类可见。

如下两个例子：

 

//代码1：内部类对外部类可见   
class Outer{   
     //创建私有内部类对象   
     public Inner in=new Inner();   
     //私有内部类   
     private class Inner{   
          ...   
     }   
}  

//代码2：外部类对内部类可见   
class Outer{   
       //外部类私有数据域   
       private int data=0;   
       //内部类   
       class Inner{   
           void print(){   
                 //内部类访问外部私有数据域   
                 System.out.println(data);   
           }    
       }   
} 

 

 

那到底这些特性的原理是什么呢？内部类的本质又是怎么一回事？

 

其实，内部类就像泛型一样都是编译器层面的事，虚拟机并不知道内部类与常规类的区别。内部类编译之后会得到两个class文件：Outer.class和Outer$Inner.class。只是在编译过程中编译器做了一些处理，至于内部类的那些特性就得益于这些处理

 

 

//反编译1  
class Outer$Inner   
{   
        Outer$Inner(Outer,Outer$Inner);  //包可见构造器   
        private Outer$Inner(Outer);   //私有构造器将设置this$0域   
        final Outer this$0;   //外部类实例域this$0  
}  

 首先编译器将外、内部类编译后放在同一个包中。在内部类中附加一个包可见构造器。这样Outer对象的Inner in = new Inner()；实际上调用的是new Outer$Inner(this,null)。因此即使是private内部类，也会通过隐含的包可见构造器成功的获得私有内部类的构造权限

 

//反编译2  
class Outer   
{   
          static int access$0(Outer);  //静态方法，返回值是外部类私有域 data 的值。   
}  

 而外部类中添加了静态方法access$0。它将Outer对象的私有域返回。

 

access$0方法的汇编代码大概是

 static int access$0(simpleTest.OutClass);
   descriptor: (LsimpleTest/OutClass;)I
   flags: ACC_STATIC, ACC_SYNTHETIC
   Code:
     stack=1, locals=1, args_size=1
        0: aload_0
        1: getfield      #12                 // Field a:I
        4: ireturn

 这里是我的代码反编译成的私有属性是代号为a的int值，外部类名叫OutClass。可以看到静态方法access$0先加载参数OutClass对象，然后获得该对象的私有属性a，将其返回

相当于你调用外部类私有属性a，就是调用OutClass.access$0(this$0);

 

总结一下编译器动的手脚

1.在内部类中创建包可见构造器，使外部类获得创建权限

2.在内部类维护一个外部类对象

3.在外部类创建访问私有变量的静态方法，使内部类获得访问权限

 

静态内部类 

静态内部类与普通内部类相比，反编译后少了一个指向外围对象的引用final Outer this$0；也就是说静态内部类无法得到其外围类对象的引用。因此，静态内部类只能范文外部类的静态成员，除此之外与非静态内部类没有任何区别

 

局部内部类--在方法中定义的内部类

局部内部类也有两个特点

1.方法内部类没有访问修饰符，方法内部类对包围它的方法之外的任何东西都不可见

2.方法内部类只能访问该方法中的局部变量，而且这些变量一定是final的

class Outter{   
      public void outMethod(){   
             final int beep=0;   
             class Inner{   
                   //使用beep   
             }   
             Inner in=new Inner();   
      }   
}  

 

反编译后发现

1.Outter中没有返回私有域的隐藏方法access$0了

2.Inner类内部多了一个对beep变量的备份隐藏域：final int val$i;

 

可以这样解释编译器这种做法，当jvm运行到创建Inner对象后，Outter类可能以及运行完毕，垃圾回收机制可能释放掉局部变量beep，编译器就在Inner类中创建一个beep的备份。但是如果Outter中的beep不停在变，内部类也必须要无时无刻盯着，为了保持外部类的方法局部变量与内部类的备份域一致。编译器就规定死这些内部类需要的局域变量必须是final常量