java 四种内部类 使用细节(含代码)

一: 内部类

    定义在类体部,方法体部,甚至比方法体更小的代码块内部的类(if 语句里面等)

    1.静态内部类（内部类中最简单的形式）

        1.声明在类体部，方法体外，并且使用static修饰的内部类
        2.访问特点可以类比静态变量和静态方法
        3.脱离外部类的实例独立创建
            在外部类的外部构建内部类的实例
                new Outer.Inner();
            在外部类的内部构建内部类的实例
                new Inner();

        4.静态内部类体部可以直接访问外部类中所有的静态成员，包含私有

          

    

[java]  view plain  copy

1. /** 
2.  * @author gress 
3.  *静态内部类 
4.  */  
5. public class StaticInnerTest {  
6.     public static void main(String[] args) {  
7.   
8.         StaticOuter.StaticInner si = new StaticOuter.StaticInner();  
9.         si.test2();  
10.         //StaticOuter.StaticInner.test();  
11.         System.out.println("si.b = "+si.b);  
12.         System.out.println("si.a = "+si.a);  
13.     //  System.out.println("StaticOuter.b  = "+StaticOuter.b);  这里报错  
14.     }  
15.   
16. }  
17.   
18. class StaticOuter {  
19. private int a = 100;  
20. private static int b = 150;  
21. public static void test(){  
22.     System.out.println("Outer static test ...");  
23. }  
24. public  void test2(){  
25.     System.out.println("Outer instabce test ...");  
26. }     
27.   
28.     static class StaticInner {  
29.         public  int a = 200;  
30.         static int b =300;  
31.         public static void test(){  
32.             System.out.println("Inner static test ...");  
33.         }  
34.         public  void test2(){  
35.             System.out.println("Inner instance test ...");  
36.             StaticOuter.test();  
37.             new StaticOuter().test2();  
38.             System.out.println("StaticOuter.b  = "+StaticOuter.b);  
39.         }     
40.     }  
41. }  

    2.成员内部类(实例内部类)

        1.没有使用static修饰的内部类。
        2.在成员内部类中不允许出现静态变量和静态方法的声明。
            static只能用在静态常量的声明上。
        3.成员内部类中可以访问外部类中所有的成员(变量，方法)，包含私有成员，如果在内部类中定义有和外部类同名的实例变量，访问：
            OuterClass.this.outerMember;
        4.构建内部类的实例，要求必须外部类的实例先存在
            外部类的外部/外部类的静态方法：new Outer().new Inner();
            外部类的实例方法：
                new Inner();

                this.new Inner();

[java]  view plain  copy

1. **  
2.  * @author gress  
3.  * 实例内部类  
4.  *  
5.  */  
6. class MemberOuter{  
7.       
8.     private String s1 = "Outer InstanceMar";  
9.     private String s2 = "OuterStatic s2";  
10.     public void setS1(String s1) {  
11.         this.s1 = s1;  
12.         new MemberOuter().new MemberInner();  
13.         this.new MemberInner();  //此时MemberOuter已经实例化完成,所以可以使用this  
14.         new MemberInner().test2();  
15.     }  
16.     public static void  test2 (){  
17.         new MemberOuter().new MemberInner();  
18.         /*this.new MemberInner();   
19.          * 此时MemberOuter没有实例化完成,所以不可以使用this 
20.          * static 是在MemberOuter构造器前使用,所以此时this不能使用 
21.          *  
22. */  
23.           
24.     }  
25.   
26.   
27.     class MemberInner{  
28.          String s1= "Inner  instanceMae  ";  
29.         static final String s4 = "static final  MemberInner";  
30.               
31.                 void test2(){  
32.                     System.out.println(" s1 =" + s1);  
33.                     System.out.println(" Outter MemberOuter.this.s1 =" + MemberOuter.this.s1);  
34.                     System.out.println("s2 = "+s2);  
35.                 }  
36.     }  
37.       
38. }  
39.   
40. public class MemberInnerTest {  
41.   
42.     public static void main (String args []){  
43.     /*  MemberOuter.MemberInner mm =  new MemberOuter().new MemberInner(); 
44.         mm.test2();*/  
45.           
46.         MemberOuter mo = new MemberOuter();  
47.         mo.setS1("");  
48.           
49.           
50.     }  
51. }  

    3.局部内部类:

        1.定义在方法体，甚至比方法体更小的代码块中
        2.类比局部变量。
        3.局部内部类是所有内部类中最少使用的一种形式。
        4.局部内部类可以访问的外部类的成员根据所在方法体不同。
            如果在静态方法中：
                可以访问外部类中所有静态成员，包含私有
            如果在实例方法中：
                可以访问外部类中所有的成员，包含私有。
          局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量必须使用final修饰。
          

[java]  view plain  copy

1. **  
2.  * @author gress 局部内部类  
3.  *  
4.  */  
5. public class LocalInnerTest {  
6.   
7.     private int a = 1;  
8.     private static int b = 2;  
9.   
10.     public void test() {  
11.         final int c = 3;  
12.         class LocalInner {  
13.             public void add1() {  
14.                 System.out.println("a= " + a);  
15.                 System.out.println("b= " + b);  
16.                 System.out.println("c= " + c);  
17.             }  
18.         }  
19.         new LocalInner().add1();  
20.     }  
21.   
22.     static public void test2() {  
23.         final int d = 5;  
24.         class LocalInner2 {  
25.             public void add1() {  
26.                 // System.out.println("a= " + a);  
27.                 System.out.println("b= " + b);  
28.                 System.out.println("c= " + d);  
29.             }  
30.         }  
31.         new LocalInner2().add1();  
32.     }  
33.   
34.     public static void main(String args[]) {  
35.   
36.         // LocalInnerTest() lc = new LocalInnerTest();  
37.         new LocalInnerTest().test2();  
38.         new LocalInnerTest().test();  
39.     }  
40. }  

    4.匿名内部类

        1.没有名字的局部内部类。
        2.没有class,interface,implements,extends关键字
        3.没有构造器。
        4.一般隐式的继承某一个父类或者实现某一个接口
        5.吃货老师讲的一个很生动的例子
        /**
         * @author gress 匿名内部类,我只会使用一次的类
         * 假如我想吃一个泡面,但我不可能建一个厂,制造一个流水线,生产一包泡面之后就在也不去使用这个泡面厂了
         * 所以这里引申出匿名内部类 ,而我们建立的泡面厂就像这里构建的一个类Pencil 铅笔类一样
         */

    

[java]  view plain  copy

1. **  
2.  * @author gress 匿名内部类,我只会使用一次的类  
3.  *   
4.  * 就假如我想吃一个泡面,但我不可能建一个厂,制造一个流水线,生产一包泡面之后就在也不去使用这个泡面厂了  
5.  * 所以这里引申出匿名内部类 ,而我们建立的泡面厂就像这里构建的一个类Pencil 铅笔类一样  
6.  */  
7. interface Pen {  
8.     public void write();  
9. }  
10.   
11. class  Pencil implements Pen {  
12.     @Override  
13.     public void write() {  
14.         //铅笔 的工厂  
15.     }  
16. }  
17.   
18. class Person {  
19.     public void user(Pen pen) {  
20.         pen.write();  
21.     }  
22. }  
23.   
24. public class AnyInnerTest {  
25.     public static void main(String args[]) {  
26.         Person guo = new Person();  
27.           
28.         guo.user(new Pen() {  
29.             @Override  
30.             public void write() {  
31.                 System.out.println("写子");  
32.             }  
33.         });  
34.     }  
35.   
36. }