内部类使用实例

内部类包括：成员内部类(和成员变量一样)、局部内部类(方法内部定义的类)、静态内部类(调用时需要指定外部类的名称)、匿名内部类(return new 接口名称{public 接口中定义的方法实现})
成员内部类：
作为外部类的成员存在，与外部类的属性和方法并存。
成员内部类注意事项:
1)成员内部类是依赖于外部类对象而创建的
2)成员内部类中不能定义静态成员
3)成员内部类可以访问外部类所有成员,包括外部类的方法
4)成员内部类访问自己定义的变量，直接使用变量名
5)成员内部类访问自己定义的变量可以使用this.变量名
6)成员内部类访问外部类与内部类同名的变量，使用外部类.this.变量名
7)如果内部类中没有与外部类同名的变量，可以直接使用外部类的变量的名进行访问
8)外部类的非静态方法访问内部类直接使用
Inner inner = new Inner();
inner.method();
9)外部类的静态方法访问内部类与在外部类外部访问成员内部类一样，使用
Outer out = new Outer();
Inner inner = out.new Inner();
inner.method();

实例：
publicclass Outer {
       private static int i = 1;
       private int j = 10;
       private int k = 20;

       Public static void outer_f1() {
       }

       Public voido uter_f2() {
       }
   
       class Inner {
              //定义一个与外部类同名的变量
              int j  = 100;
              int inner_i = 1;
              void method() {
                     //直接使用外部类变量
                     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();
              }
       }
       //外部类的非静态方法访问成员内部类,直接实例话
       publicvoidouter_f3() {
              Inner inner = new Inner();
              inner.inner_f1();
       }
       // 外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样,需要通过外部类对象创建内部类
       publicstaticvoidouter_f4() {
              Outer out = new Outer();
              Inner inner = out.new Inner();
              inner.inner_f1();
       }
       publicstaticvoid main(String[] args) {
              //在外部类的外部使用成员内部类，需要使用外部类的对象         
              Outer out = new Outer();
              Outer.Inner outin = out.new Inner();
              outin.inner_f1();
       }
}

局部内部类
局部内部类是在外部的方法中定义的内部类
局部内部类与局部变量类似，不能有访问修饰符
局部内部类可以访问当前代码块的常量和所有外部成员
注意事项:
1)局部内部类中不可以定义静态变量
2)如果局部内部类中没有与外部类同名的变量，可以直接访问访问外部类的变量名
3)可以访问局部内部类所在的方法的final变量。
4)访问局部内部类中与外部类同名的外部变量使用 外部类名.this.变量名
5)在方法中定义完局部内部类后要使用new Inner()，否则局部内部类定义的就没有意义了
6)在外部类的外部调用局部内部类，通过
Outer out = new Outer();
out.method(3);

实例
publicclass Outer {
       privateints = 100;
       privateintout_i = 1;
       publicvoid f(finalint k) {
              finalint s = 200;
              int i = 1;
              finalint j = 10;
             
              //定义在方法内部
              class Inner {
                     //定义与外部类同名的变量
                     ints = 300;
                    
                     Inner(int k) {
                            inner_f(k);
                     }
                     intinner_i = 100;
                     void inner_f(int k) {
                            //直接访问内同名的外部变量
                            System.out.println(out_i);
                            //访问final的局部成员变量
                            System.out.println(j);
                            //System.out.println(i);
                            //is.变量名访问的也是内部类变量
                            System.out.println(this.s);
                            //类名.this.内部类变量名访问的是外部类变量
                            System.out.priln(Outer.this.s);
                     }
              }
              new Inner(k);
       }
       publicstaticvoid main(String[] args) {
              // 访问局部内部类必须先有外部类对象
              Outer out = new Outer();
              out.f(3);
       }
}
静态内部类(嵌套类)
静态内部类就是将成员内部类声明外static
注意事项:
1)静态内部类的实例化不依赖于外部类的对象
2)静态内部类不能访问外部类的非静态成员变量
3)静态内部类可以定义静态或是非静态的成员变量
4)静态内部可以使用public,protected,private修饰
5)外部类内部访问静态内部类的静态成员变量和静态方法使用
6)在外部类外部生成静态内部类使用
Outer.Inner in = new Outer.Inner();


Inner.field
Inner.method

6)外部类访问静态内部类的非静态变量或是方法，需要实例化静态内部类后再调用
Inner inner = new Inner();
inner.field
inner.method

实例:
publicclass Outer {
       privatestaticinti = 1;
       privateintj = 10;
       public tatic vid uter_f1() {
       }
       publicvoidouter_f2() {
       }
       staticclass Inner {
              staticintinner_i = 100;
              intinner_j = 200;
              staticvoidinner_f1() {
                      //静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
                     System.out.println("Outer.i" + i);
                     outer_f1();
              }
              voidinner_f2() {
                     // 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
                     // System.out.println("Outer.i"+j);
                     // outer_f2();
              }
       }
       publicvoidouter_f3() {
              // 外部类访问内部类的静态成员：内部类.静态成员
              System.out.println(Inner.inner_i);
              Inner.inner_f1();
              // 外部类访问内部类的非静态成员:实例化内部类即可
              Inner inner = new Inner();
              inner.inner_f2();
       }
       publicstaticvoid main(String[] args) {
              newOuter().outer_f3(); 
               Outer.Inner in = new Outer.Inner();    
  }
}
匿名内部类
实例
public class Parcel6 {
        public Contents cont() {
                return new Contents() {
                     private int i = 11;
                     public int value() {
                            return i;
                     }
              }; // 在这里需要一个分号
        }
        public static void main(String[] args) {
                Parcel6 p = new Parcel6();
                Contents c = p.cont();        }
}

内部类若是要引用局部变量，则局部变量必须是final的。，
在静态方法中不能直接创建内部类对象