内部类，计算机面向对象程序设计概念。向对象程序设计中，可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes）,它有两种类型，即静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类(inner)。内部类是JAVA语言的主要附加部分。内部类几乎可以处于一个类内部任何位置，可以与实例变量处于同一级，或处于方法之内，甚至是一个表达式的一部分。

定义

表现形式

优点

实例和运行结果

访问类型

访问内容

定义

内部类是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

访问内容

我是静态内部类

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

和外部类静态方法

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

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

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

和外部类实例方法

和外部类静态方法

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