内部类

内部类:指在一个外部类内部在定义一个类.内部类作为一个外部类的成员.并依附外部类而存在.

分为4种   源码传送门

1. 成员内部类 作为外部类的一个成员存在,与外部类的属性方法并列.
   1. 　　

      public class Outer {
          private static int i = 1;
          private int j = 10;
          private int k = 20;
          
          public  static void outer_f1(){
              
          }
          public  void outer_f2(){
              
          }
          
          //成员内部类中不能定义静态成员
          //成员内部类中,可以访问所有外部成员
          class Inner{
      //        static int inner_i = 100;//内部类不允许定义静态变量
              int j = 100;//内部类和外部类实例变量可以共存
              int inner_i = 1;
              void inner_f1(){
                  System.out.println(i);
                  
                  //内部类访问内部类自己变量名时,直接用变量名
                  System.out.println(j);
                  //也可以this.变量名
                  System.out.println(this.j);
                  
                  //在内部类中访问外部类中与内部类同名的实例变量     用外部类名.this.变量名
                  System.out.println(Outer.this.j);
                  //没有与外部类同名的变量,内部类可以直接访问外部类变量
                  System.out.println(k);
                  outer_f1();
                  outer_f2();
              }
          }
          
          public void outer_f3(){
              //外部方法使用内部方法需要创建内部类对象
              Inner inter = new Inner();//对象实例化
              inter.inner_f1();
          }
          //外部类的静态方法访问成员内部类,与在外部类访问成员内部类一样.
          public static void outer_f4(){
      //        step1: 建立外部类对象
              Outer outer = new Outer();
      //        step2:根据外部类对象建立内部类对象
              Inner inner = outer.new Inner();
      //        setp3:访问内部类方法
              inner.inner_f1();
          }
          //主方法main
          public static void main(String[] args) {
      //        outer_f4();//和下面3条输出结果一样
          
      //        Outer outer = new Outer();
      //        Inner inner = outer.new Inner();
      //        inner.inner_f1();
              
              Outer outer = new Outer();
              Outer.Inner outin = outer.new Inner();
              outin.inner_f1();
          }
      }

      注意:内部类是一个编译时的概念,一旦编译成功,就会成为不完全不同的2个类.对于一个名为Outer的外部类和其内部Inner的内部类.编译完成后出现Outer.class和Outer$Inner.class.

局部内部类  定义在外部内类的方法内部.

1. public class Outer {
       private int s = 100;
       private int out_i = 10;
       
       public   void f(final int k){
           final int s = 200;
           int i = 1;
           final int j = 10;
           
           //局部内部类,定义在方法内部
           class Inner{
               int s = 300; //可以定义与外部内同名变量
               int inner_i = 100;
               //static int m =20;//不能定义静态变量
               Inner (int k){
                   inner_f(k);
               }
                void inner_f(int k) {
                    //如果内部类没有与外部类同名变量,内部类可以直接访问外部类实例变量
                   System.out.println(out_i);
                   //可以访问外部类方法内的局部变量,但是变量必须是final
                   System.out.println(j);
                   //如果内部和外部均有,访问的是内部类变量.
                   System.out.println(s);
                   //用this.变量名访问的是内部变量
                   System.out.println(this.s);
                   //访问外部变量用外部类名.this.s
                   System.out.println(Outer.this.s);
               }
           }
           new Inner(k);
       }
       
       //主方法main
       public static void main(String[] args) {
           //访问内部内必须先有外部类对象
           Outer out = new Outer();
           out.f(3);
       }
   }

2. 静态内部类(嵌套类)
   1. 不需要内部类与外部类之间有联系,内部类可以声明为static.不同内部类隐含保存了一个引用,指向创建他的外围类对象
   2. 当内部类使用static 时,
      1. 要创建一个嵌套类对象就不需要其外围类对象.
      2. 不能从嵌套类对象中访问非静态类的外围类对象

   3. public class Outer {
          private static int i= 1;//定义静态变量
          private int j = 10;
          public  static void outer_f1(){
              
          }
          public void outer_f2(){
              
          }
          //静态内部类
          //静态内部类中可以用public ,protected private 修饰
          //可以定义静态成员和非静态成员
          static class Inner{
              static int inner_i = 100;
              int inner_j = 200;
              static void inner_f1(){
                  System.out.println("Outer.i:"+i);
                  outer_f1();
              }
              void inner_f2(){
      //            静态内部类不能访问外部类的非静态成员(包括变量和方法)
      //            System.out.println("Outer.i"+j);
      //            outer_f2();
              }
          }
          
          public void outer_f3(){
              //外部类访问内部类的静态成员  内部类.成员变量
              System.out.println(Inner.inner_i);
              Inner.inner_f1();
              
              //外部类访问内部类非静态成员 实例化内部类即可
              Inner inner = new Inner();
              inner.inner_f2();
          }
          public static void main(String [] args ){
              new Outer().outer_f3();
          }
      }

3. 匿名内部类  简而言之就是没有名字的内部类
   1. 满足以下条件使用内部类比较合适
      1. 只用到类的一个实例.
      2. 类在定义后马上用到.
      3. 类非常小(SUN推荐4行代码以下).
      4. 给类命名并不会导致你的代码更容易被理解.
   2. 使用匿名内部类注意以下几个原则
      1. 匿名内部类不能有构造方法.
      2. 不能定义任何静态成员, 方法,和类.
      3. 匿名内部类不能是public,protected,private,static.
      4. 只能创建匿名内部类的一个实例.
      5. 一个匿名内部类一定是在new的后面.用其隐含实现一个接口或者实现一个类.
      6. 因为匿名内部类是一个局部内部类,所有局部内部类的限制对其均有效.
   3. 代码 参考http://www.cnblogs.com/nerxious/archive/2013/01/25/2876489.html