Java内部类

1，成员内部类

就是在一个类中定义一个类，注意这个内部类可以在类的成员函数中使用，也可以由外部程序调用，取决于内部类的访问级别，如果设置为private，则外部程序不能直接使用这个内部类。

1. package wz.learning;  
2.     
3. public class Example16 {  
4.     public static void main(String[] args) {  
5.     
6.         Outer outer = new Outer();  
7.         outer.test();  
8.         
9.         //外部调用内部类，注意必须是一个实例.new 内部类的方式，  
10.         //下面两种都是可以的。     
11.         //Outer.Inner i = (new Outer()).new Inner();  
12.         Outer.ClassInner i = outer.new ClassInner();  
13.         i.show();  
14.     }  
15. }  
16.     
17. class Outer{  
18.     int num;  
19.     public void test(){  
20.         num = 5;  
21.         ClassInner inner = new ClassInner();  
22.         inner.show();         
23.     }  
24.     // 这里可以设置ClassInner为private，这样仅有Outer类可以访问      
25.     // Class inner class  
26.     class ClassInner{  
27.         void show(){  
28.             System.out.println("ClassInner num=" + num);  
29.         }  
30.     }  
31. }  

2，函数内部类

在函数的内部也可以声明内部类，当然这个内部类只能在函数内部使用，并且注意，必须先声明内部类，再使用，否则编译出错。

1. package wz.learning;  
2.     
3. public class Example16 {  
4.     public static void main(String[] args) {  
5.     
6.         Outer outer = new Outer();  
7.         outer.test();     
8.     
9.     }  
10. }  
11.     
12. class Outer{  
13.     int num;  
14.     public void test(){  
15.         num = 5;  
16.         // 这里需要先定义MethodInner，再new MethodInner();
17.         // Method inner class  
18.         class MethodInner{  
19.             void show(){  
20.                 System.out.println("MethodInner num=" + num);  
21.             }  
22.         }  
23.         MethodInner inner2 = new MethodInner();  
24.         inner2.show();  
25.     }  
26.     
27. }  

3，静态内部类

在一个类中，声明一个带有static关键字的内部类，这个内部类可以访问类中的静态成员变量。

1. package wz.learning;  
2.     
3. public class Example18 {  
4.     
5.     public static void main(String[] args) {  
6.     
7.         Outer18.Inner inner = new Outer18.Inner();  
8.         inner.show();  
9.     }  
10.     
11. }  
12. class Outer18{  
13.     private static int num=6;  
14.     static class Inner{  
15.         void show(){  
16.             System.out.println("num=" + num);  
17.         }  
18.     }  
19. }