java的内部类

内部类就是在类的内部再定义一个类，优点就是可以调用外部类的方法和私有变量

内部类分为静态内部类（静态绑定），匿名内部类，以及局部内部类。

静态内部类：在类中被static修饰的内部类

匿名内部类：不常用 如果只使用一次，可以写成匿名内部类

局部内部类：在方法中定义的类叫做局部内部类，在方法中可以new 多次

Outer类中定义内部类Inner,以及静态内部类Inner2

[java]  view plain  copy

1. package Com;  
2.   
3. public class Outer {  
4.     private String name;  
5.       
6.       
7.     //内部类在普通方法调用方式  
8.     public void show()  
9.     {  
10.         System.out.println(name);  
11.         System.out.println("Outer .... show");  
12.         //第一种方式 在类的内部调用不需要创建外部对象（当前外部对象Outer()对象已经有了）  
13.         Inner inner = new Inner();  
14.         //第二种方式 创建外部对象Outer(),再调用外部对象的内部类对象Inner()   
15.         Outer.Inner inner2 = new Outer().new Inner();  
16.     }  
17.       
18.       
19.     //内部类在静态方法中的调用方式  
20.     public static void staFun() {  
21.         // 静态方法不产生类的对象，是在编译期放入内存的，静态方法属于类不属于对象  
22.         //Inner inner = new Inner();  
23.         //在静态方法中，必须创建外部对象，才能调用内部类  
24.         Outer.Inner inner2 = new Outer().new Inner();  
25.     }  
26.       
27.       
28.       
29.     //普通内部类  
30.     class Inner{  
31.         int age;  
32.         public void go()  
33.         {  
34.             System.out.println("innner....go");  
35.         }  
36.     }  
37.     //静态内部类  
38.     static class InnerSta{  
39.         public void go2()  
40.         {  
41.             System.out.println("InnerSta ...go");  
42.         }  
43.     }  
44. }  

main:

[java]  view plain  copy

1. package Com;  
2.   
3. import Com.Outer.InnerSta;  
4.   
5. public class main {  
6.   
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.           
12.        // 普通内部类  需要先创建外部对象Outer,再创建内部对象Inner  
13.        Outer.Inner inner = new Outer().new Inner();  
14.        inner.go();  
15.        // 静态内部类 内部类属于外部类，直接用类名调用内部类即可创建对象  
16.        InnerSta inner2 = new Outer.InnerSta();  
17.        inner2.go2();  
18.   
19.     }  
20.   
21. }  

内部类中使用接口和抽象类：

[java]  view plain  copy

1. package Com;  
2.   
3. public class Java3 {  
4.     public void show()  
5.     {  
6.           
7.     }  
8.       
9.     //内部类是接口  
10.     interface Inner{  
11.         void in();  
12.     }  
13.     //内部类是抽象类  
14.     abstract class B{  
15.            
16.      }  
17.     //继承内部类抽象类，实现内部类接口  
18.      class A extends B implements Inner{  
19.         @Override  
20.         public void  in()  
21.         {  
22.               
23.         }  
24.     }  
25.        
26. }