内部类

定义

　　内部类是定义在其他类内部的类。

　　它几乎可以处于类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分！

　　内部类是JAVA语言的主要附加部分。

表现形式

　　⒈ 静态内部类

　　⒉ 成员内部类

　　⒊ 局部内部类

　　⒋ 匿名内部类

优点

　　⒈ 内部类对象可以访问创建它的对象的实现，包括私有数据；

　　⒉ 内部类不为同一包的其他类所见，具有很好的封装性；

　　⒊ 使用内部类可以很方便的编写事件驱动程序；

　　⒋ 匿名内部类可以方便的定义运行时回调；

实例和运行结果

　　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

　　我是静态内部类

　　我可以访问 外部类的类变量

　　和外部类静态方法

　　我可以访问外部的静态变量 外部静态变量

　　我是成员级内部类，非静态内部类

　　我可以访问 外部类的实例变量

　　和外部类实例方法

　　和外部类静态方法

　　我可以访问外部的静态变量 外部静态变量