标题：内部类
定义
内部类是JAVA语言的主要附加部分。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
其一、在一个类（外部类）中直接定义的内部类；
其二、在一个方法（外部类的方法）中定义的内部类;
其三、匿名内部类。
表现形式
⒈ 静态内部类
⒉ 成员内部类
⒊ 局部内部类
⒋ 匿名内部类
优点
⒈ 内部类对象可以访问创建它的对象的实现，包括私有数据；
⒉ 内部类不为同一包的其他类所见，具有很好的封装性；
⒊ 使用内部类可以很方便的编写事件驱动程序；
⒋ 匿名内部类可以方便的定义运行时回调；
5.内部类可以方便的定义
实例和运行结果
1. package test.jdk;  
2.   
3. /** 
4.  * 内部类的收集与整理 
5.  *  
6.  * @author 赵学庆 www.
7.  */  
8. public class InnerTest {  
9.   private String instAtt = "实例变量";  
10.   
11.   private static String staticAtt = "静态变量";  
12.   
13.   public void test() {  
14.     int methodAtt = 1;  
15.     final int methodFinalAtt = 2;  
16.     // 非静态方法里的内部类  
17.     class staticMethodInnerClass {  
18.       @Override  
19.       public String toString() {  
20.         // 非静态方法里无法访问实例的外部变量  
21.         System.out.println("非静态方法的内部类可以访问外部类的实例变量：" + instAtt);  
22.         System.out.println("非静态方法的内部类可以访问外部类的静态变量：" + staticAtt);  
23.         // 非静态方法里无法访问方法的非final的变量  
24.         // System.out.println(methodAtt);  
25.         System.out.println("非静态方法的内部类可以访问方法的final变量：" + methodFinalAtt);  
26.         return "my nickname is white";  
27.       }  
28.     }  
29.     new staticMethodInnerClass().toString();  
30.     new Object() {  
31.       @Override  
32.       public String toString() {  
33.         System.out.println("非静态方法的匿名内部类可以访问外部类的实例变量：" + instAtt);  
34.         System.out.println("非静态方法的匿名内部类可以访问外部类的静态变量：" + staticAtt);  
35.         // 静态方法里匿名内部类无法访问方法的非final的变量  
36.         // System.out.println(methodAtt);  
37.         System.out.println("非静态方法的匿名内部类可以访问方法的final变量：" + methodFinalAtt);  
38.         return "我是匿名内部类";  
39.       }  
40.     }.toString();  
41.   }  
42.   
43.   public static void main(String blackbat[]) {  
44.     int methodAtt = 1;  
45.     final int methodFinalAtt = 2;  
46.     // 静态方法里的内部类  
47.     class staticMethodInnerClass {  
48.       @Override  
49.       public String toString() {  
50.         // 静态方法里无法访问实例的外部变量  
51.         // System.out.println(instAtt);  
52.         System.out.println("静态方法的内部类可以访问外部类的静态变量：" + staticAtt);  
53.         // 静态方法里无法访问方法的非final的变量  
54.         // System.out.println(methodAtt);  
55.         System.out.println("静态方法的内部类可以访问方法的final变量：" + methodFinalAtt);  
56.         return "my nickname is white";  
57.       }  
58.     }  
59.     new staticMethodInnerClass().toString();  
60.     new Object() {  
61.       @Override  
62.       public String toString() {  
63.         // 静态方法的匿名内部类不能访问外部类的非静态变量  
64.         // System.out.println("非静态方法的匿名内部类可以访问外部类的非静态变量：" + instAtt);  
65.         System.out.println("非静态方法的匿名内部类可以访问外部类的静态变量：" + staticAtt);  
66.         // 静态方法里匿名内部类无法访问方法的非final的变量  
67.         // System.out.println(methodAtt);  
68.         System.out.println("非静态方法的匿名内部类可以访问方法的final变量：" + methodFinalAtt);  
69.         return "我是匿名内部类";  
70.       }  
71.     }.toString();  
72.     new InnerTest().test();  
73.     // 建立静态内部类(static Inner Class)的对象  
74.     ImOutClass.StaticInnerClass staticIC = new ImOutClass.StaticInnerClass();  
75.     staticIC.access();  
76.     /* 
77.      * 建立非静态内部类(non-static Inner Class)的对象. <br>注意这种建立对象的格式 首先创建外部类的对象 然后使用对象.new 来创建。 
78.      */  
79.     ImOutClass outC = new ImOutClass();  
80.     ImOutClass.InstInnerClass inC = outC.new InstInnerClass();  
81.     inC.access();  
82.   }  
83. }  
84.   
85. class ImOutClass {  
86.   private static String staticAtt = " 外部类的类变量 ";  
87.   
88.   private String instAtt = " 外部类的实例变量 ";  
89.   
90.   private static String xx = "外部静态变量";  
91.   
92.   // private String xx = "外部类的实例变量";  
93.   // 外部类的非静态方法  
94.   public void instanMethod() {  
95.     System.out.println(" 和外部类实例方法 ");  
96.   }  
97.   
98.   // 外部类的静态方法  
99.   public static void staticMethod() {  
100.     System.out.println(" 和外部类静态方法 ");  
101.   }  
102.   
103.   // 静态内部类(static Inner Class)  
104.   public static class StaticInnerClass {  
105.     public StaticInnerClass() {  
106.       System.out.println(" 我是静态内部类 ");  
107.     }  
108.   
109.     public void access() {  
110.       System.out.println(" 我可以访问 " + staticAtt);  
111.       staticMethod();  
112.       System.out.println(" 我可以访问外部的静态变量 " + xx);  
113.       // 非静态的方法 instanMethod() 无法从静态的地方使用  
114.       // instanMethod();  
115.     }  
116.   }  
117.   
118.   // 非静态内部类(non-static Inner Class)  
119.   public class InstInnerClass {  
120.     public InstInnerClass() {  
121.       System.out.println(" 我是成员级内部类，非静态内部类 ");  
122.     }  
123.   
124.     public void access() {  
125.       System.out.println(" 我可以访问 " + instAtt);  
126.       instanMethod();  
127.       staticMethod();  
128.       System.out.println(" 我可以访问外部的静态变量 " + xx);  
129.     }  
130.   }  
131. }
访问类型
静态方法的内部类可以访问外部类的静态变量：静态变量
静态方法的内部类可以访问方法的final变量：2
静态方法的匿名内部类可以访问外部类的静态变量：静态变量
静态方法的匿名内部类可以访问方法的final变量：2
非静态方法的内部类可以访问外部类的实例变量：实例变量
非静态方法的内部类可以访问外部类的静态变量：静态变量
非静态方法的内部类可以访问方法的final变量：2
非静态方法的匿名内部类可以访问外部类的实例变量：实例变量
非静态方法的匿名内部类可以访问外部类的静态变量：静态变量
非静态方法的匿名内部类可以访问方法的final变量：2
访问内容
我是静态内部类
我可以访问 外部类的类变量
和外部类静态方法
我可以访问外部的静态变量 外部静态变量
我是成员级内部类，非静态内部类
我可以访问 外部类的实例变量
和外部类实例方法
和外部类静态方法
我可以访问外部的静态变量 外部静态变量