内部类详解（转）

内部类有两种情况：

1，在类中定义一个类（私有内部类，静态内部类）

2，在方法中定义一个类（局部内部类，匿名内部类）

 

一，私有内部类，在方法之间定义的内部类，非静态。

1，我们首先看看类中内部类的两个特点：

1）在外部类的作用范围内可以任意创建内部类对象，即使内部类是私有的（私有内部类）。即内部类对包围它的外部类可见。

2）在内部类中可以访问其外部类的所有域，即便是私有域。即外部类对内部类可见。

2，问题来了，上面两个特点到底如何办到的呢？内部类的“内部”到底发生了什么：

其实，内部类是Java编译器一手操办的。虚拟机并不知道内部类与常规类有什么不同——对内部类进行编译后发现有两个class文件：Outer.class和Outer$Inner.class（这说明内部类Inner仍然被编译成一个独立的类Outer$Inner.class，而不是Outer类的某一个域。虚拟机运行时，也是把Inner作为一种常规类来处理！）

+但问题来了，既然是两个常规类，为什么它们之间可以互相访问私有域呢（最开始提到的两个内部类特点）？我们利用reflect反射机制来探查一下内部类编译后的情况。

1）反编译1发现了三个隐含的成分——

//反编译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内部类，也会通过隐含的包可见构造器成功地获得私有内部类的构造权限！）

+再者Outer$Inner类中有一个指向外部类Outer的引用this$0（那么通过这个引用就可以方便地得到外部类对象中可见成员。但是Outer类中的private成员是如何访问到的呢？）

2）反编译2发现了一个隐含的成分——（为什么内部类可以引用外部类的私有域）

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

原因的关键就在编译器在外围类中添加了静态方法access$0。它将返回值作为参数传递给他的对象域data（这样内部类Inner中的打印语句：System.out.println(data);实际上运行的时候调用的是：System.out.println(this$0.access$0(Outer));！）

 

二，静态内部类，在方法间定义的内部类，静态。

1，内部类也有静态的区别，这就是静态内部类，我们来看看代码：

package hr.test;   
//代码3：静态内部类对外部变量的引用   
public class Outer{     
    private static int i=0;           
    //创建静态内部类对象   
    public Inner in=new Inner();     
    //静态   
    private static class Inner{     
        public void print(){   
            System.out.println(i);   //如果i不是静态变量，这里将无法通过编译。   
        }   
    }     
  
}

2，静态内部类和私有内部类最大的区别在于，静态内部类中无法引用到其外围类的非静态成员：

//反编译3  
class Outer$Inner   
{   
      private Outer$Inner();   
      Outer$Inner(hr.test.Outer$Inner);   
}

与上面私有内部类反编译1比较发现，少了一个指向外围类对象的引用final Outer this$0;也就是说静态内部类无法得到其外围类对象的引用，那么自然也就无法访问外围类的非静态成员了。（因此，静态内部类只能访问其外围类的静态成员，除此之外与非静态内部类没有任何区别！）

 

三，局部内部类，在方法中定义的内部类。

1，方法内部类也有两个特点：

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

2）方法内部类只能够访问该方法中的局部变量，所以也叫局部内部类。而且这些局部变量一定要是final修饰的常量。

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

2，这又是为什么呢：

1）我们首先对Outter类进行反射发现，Outter中再也没有返回私有域的隐藏方法了。

2）对Inner类的反射发现，Inner类内部多了一个对beep变量的备份隐藏域：final int val$i;

3，我们可以这样解释Inner类中的这个备份常量域：

1）首先当JVM运行到需要创建Inner对象之后，Outter类已经全部运行完毕，这时垃圾回收机制很有可能释放掉局部变量beep。那么Inner类到哪去找beep变量呢——编译器又出来帮我们解决了这个问题，它在Inner类中创建了一个beep的备份，也就是说即使Outter中的beep被回收了，Inner中还有一个备份存在，自然就不怕找不到了。

2）但问题又来了，如果Outter中的beep不停地变化，那岂不是也要让备份的beep变量无时无刻地变化？——为了保持局部变量与局部内部类中备份域保持一致，编译器不得不规定死这些局部域必须是常量，一旦赋值不能再发生变化了。（这就是为什么局部内部类应用外部方法的域必须是常量域的原因所在了！）