Java内部类

内部类：定义在一个类里面或者方法里面的类。 
        编译后生成的两个独立的类：Outer.class 和Outer$Inner.class。 
   内部类的分类： 
      1.静态内部类：静态内部类定义在类中，任何方法外，用static修饰 
                              静态内部类只能访问外部类的静态成员。 

       非静态内部类里面不能定义static属性或者方法
       在外部类的外部，要创建一个静态内部类对象不需要外部类对象： 
                Outer.Inner in = new Outer.Inner(); //Outer类不会实例化，初始化
            在本类内部生成内部类对象的方式： 
                Inner in = new Inner();    

            但是在非静态类，那么实例化格式为：

             OutClass out = new OutClass();

             OutClass.innerClass inner = out.new innerClass (); 
     
       2.成员内部类（非static）：作为外部类的一个成员存在，与外部类的属性、方法并列 ,

               类似于类的一个方法或者成员属性

            2.1成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。  

            2.2内部类和外部类的实例变量允许命名冲突。 
                在内部类中访问实例变量：this.属性 
                在内部类访问外部类的实例变量：外部类名.this.属性 
           2.3 在外部类的外部，要创建一个成员内部类对象，要首先建立一个外部类对象，

                 然后再创建一个成员内部类对象。 
                Outer out = new Outer(); 
                Outer.Inner in = out.new Inner(); 
           2.4 在本类内部生成内部类对象的方式： 
                在静态方法中：Inner in = new Outer().new Inner(); 
                在非静态方法中：Inner in = this.new Inner(); 或者 Inner in = new Outer().new Inner(); 

                还有一种根据方法获取

            public class outClass{

               private innerClass inner;

                public innerClass getInstance(){

                     if(inner == null){

                           inner = new innerClass();

                     }

                    return inner;

               }

               class innerClass{ }

            }
            成员内部类不可以有静态成员，这是因为静态属性是在加载类的时候创建，这个时候内部类还没有被创建。 
                 
       3.局部内部类：在外部类的方法中定义或者作用域的内部类 
            3.1 局部内部类就像是方法里面的一个局部变量一样，在局部内部类前不可以加修饰符public和private，

                  其作用域为定义它的代码块。 
            3.2 局部内部类不仅可以访问外部类的实例变量（static），还可以访问外部类的局部变量，

                   配合接口使用，来做到强制弱耦合。 
            在外部类的外部不可创建局部内部类对象，只能在局部内部类所在的方法中创建： 
                Inner in = new Inner(); 
             
        4.匿名内部类：一种特殊的局部内部类 
            没有名字，也没有class、extends、implements关键字 
            用一种隐含的方式实现一个接口或继承一个类，并且只能创建一次实例。 
            实现方式：在某个语句中，new 父类/父接口名字(){ 类体中实现方法 } 
                例如： 
                    TreesSet ts = new TreeSet(new Comparator(){ 
                        public int compare(Object o1, Object o2){ 
                            return 0; 
                        } 
                    }); 
            匿名内部类属于局部内部类，那么局部内部类的所有限制都对其生效。 
            匿名内部类是唯一一种无构造方法的类，因为构造器的名字必须合类名相同，而匿名内部类没有类名。

 

另外对内部类的一个编译情况做一个解析说明

Outer.class 和Outer$Inner.class

在反编译Outer$Inner.class 我们会发现有一行

      final com.test.Outer this$0;

    这行是一个指向外部类对象Outer的指针，编译器会自动为成员内部类添加了一个指向外部类对象的引用

   再看看内部类的构造器： 

       public com.test.Outer$Inner(com.test.Outer);

　　虽然定义的内部类的构造器是无参构造器，编译器还是会默认添加一个参数，该参数的类型为指向外部类对象的一个引用，所以成员内部类中的Outer this&0 指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的，如果没有创建外部类的对象，则无法对Outter this&0引用进行初始化赋值，也就无法创建成员内部类的对象了。

 

重点说明一下

局部内部类和匿名内部类只能访问局部final变量

 public class Outer{

      public void mothed1(){

          final int a = 10;

          new Thread(){

                public void run() {

                   System.out.println(a);

            };

        }.start();

      }

}

这段代码编译后形成两个class文件  Outer.class 和Outer$1.class

其中 局部内部类或者是匿名类为 Outer$1.class

对应的final int a = 10 需要添加final的原因，

当mothed1方法执行完毕之后，变量a的生命周期就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问变量a就不可能了，

编译器会自动默认在匿名内部类（局部内部类）的常量池中添加一个内容相等的字面量或直接将相应的字节码嵌入到执行字节码中