内部类
定义可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes）,它有两种类型:
静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为
内部类(inner)。
内部类是JAVA语言的主要附加部分。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
其一、在一个类（外部类）中直接定义的内部类；
其二、在一个方法（外部类的方法）中定义的内部类;
其三、匿名内部类。
内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分！
表现形式⒈ 静态内部类
⒉ 成员内部类
⒊ 局部内部类
⒋ 匿名内部类
优点⒈ 内部类对象可以访问创建它的对象的实现，包括私有数据；
⒉ 内部类不为同一包的其他类所见，具有很好的封装性；
⒊ 使用内部类可以很方便的编写事件驱动程序；
⒋ 匿名内部类可以方便的定义运行时回调；
实例和运行结果1. package test.jdk;
2.
3. /**
4. * 内部类的收集与整理
5. *
6. * @author 赵学庆 www.java2000.net
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
我是静态内部类
我可以访问 外部类的类变量
和外部类静态方法
我可以访问外部的静态变量 外部静态变量
我是成员级内部类，非静态内部类
我可以访问 外部类的实例变量
和外部类实例方法
和外部类静态方法
我可以访问外部的静态变量 外部静态变量