深入了解java嵌套類和内部類

一、什麼是嵌套類及内部類

　　能夠在一個類的内部定義還有一個類。這樣的類稱為嵌套類（nested classes），它有兩種類型：靜态嵌套類和非靜态嵌套類。靜态嵌套類使用非常少，最重要的是非靜态嵌套類，也即是被稱作為内部類（inner）。嵌套類從JDK1.1開始引入。當中inner類又可分為三種：

　　其一、在一個類（外部類）中直接定義的内部類。

　　其二、在一個方法（外部類的方法）中定義的内部類；

　　其三、匿名内部類。

　　以下，我将說明這幾種嵌套類的使用及注意事項。

二、靜态嵌套類

　　例如以下所看到的代碼為定義一個靜态嵌套類，

1. public class StaticTest {   
2.         private static String name = "javaJohn";　          
3. 　　private String id = "X001";  
4. 　　static class Person{  
5. 　　　　private String address = "swjtu,chenDu,China";  
6. 　　　　public String mail = "[email protected]";//内部類公有成員  
7. 　　　　public void display(){  
8. 　　　　　　//System.out.println(id);//不能直接訪問外部類的非靜态成員  
9. 　　　　　　System.out.println(name);//僅僅能直接訪問外部類的靜态成員  
10. 　　　　　　System.out.println("Inner "+address);//訪問本内部類成員。
11. 　　　　}  
12. 　　}  
13. 　　public void printInfo(){  
14. 　　　　Person person = new Person();  
15. 　　　　person.display();  
16. 　　　　//System.out.println(mail);//不可訪問  
17. 　　　　//System.out.println(address);//不可訪問  
18. 　　　　System.out.println(person.address);//能夠訪問内部類的私有成員  
19. 　　　　System.out.println(person.mail);//能夠訪問内部類的公有成員  
21. 　　public static void main(String[] args) {  
22. 　　StaticTest staticTest = new StaticTest();  
23. 　　staticTest.printInfo();  
24. }  

　　在靜态嵌套類内部，不能訪問外部類的非靜态成員。這是由Java文法中"靜态方法不能直接訪問非靜态成員"所限定。

若想訪問外部類的變量，必須通過其他方法解決，由于這個原因，靜态嵌套類使用非常少。注意，外部類訪問内部類的的成員有些特别，不能直接訪問。但能夠通過内部類來訪問。這是由于靜态嵌套内的全部成員和方法默覺得靜态的了。

同一時候注意。内部靜态類Person僅僅在類StaticTest 範圍内可見，若在其他類中引用或初始化，均是錯誤的。

　　例如以下所看到的代碼為在外部類中定義兩個内部類及它們的調用關系：

　　

1. public class Outer {   
2.          　　int outer_x = 100;  
3. 　　　　class Inner{  
4. 　　　　　　public int y = 10;  
5. 　　　　　　private int z = 9;  
6. 　　　　　　int m = 5;  
7. 　　　　　　public void display(){  
8. 　　　　　　　　System.out.println("display outer_x:"+ outer_x);  
9. 　　　　　　}  
10. 　　　　　　private void display2(){  
14. 　　　　void test(){  
15. 　　　　　　Inner inner = new Inner();  
16. 　　　　　　inner.display();  
17. 　　　　　　inner.display2();  
18. 　　　　　　//System.out.println("Inner y:" + y);//不能訪問内部内變量  
19. 　　　　　　System.out.println("Inner y:" + inner.y);//能夠訪問  
20. 　　　　　　System.out.println("Inner z:" + inner.z);//能夠訪問  
21. 　　　　　　System.out.println("Inner m:" + inner.m);//能夠訪問  
22. 　　　　　　InnerTwo innerTwo = new InnerTwo();  
23. 　　　　　　innerTwo.show();  
25. 　　　　class InnerTwo{  
26. 　　　　　　Inner innerx = new Inner();  
27. 　　　　　　public void show(){  
28. 　　　　　　　　//System.out.println(y);//不可訪問Innter的y成員  
29. 　　　　　　　　//System.out.println(Inner.y);//不可直接訪問Inner的不論什麼成員和方法  
30. 　　　　　　　　innerx.display();//能夠訪問  
31. 　　　　　　　　innerx.display2();//能夠訪問  
32. 　　　　　　　　System.out.println(innerx.y);//能夠訪問  
33. 　　　　　　　　System.out.println(innerx.z);//能夠訪問  
34. 　　　　　　　　System.out.println(innerx.m);//能夠訪問  
37. 　　　　public static void main(String args[]){  
38. 　　　　　　Outer outer = new Outer();  
39. 　　　　　　outer.test();  

　　以上代碼須要說明有，對于内部類。通常在定義類的classkeyword前不加public 或 private等限制符，若加了沒有不論什麼影響，同一時候好像這些限定符對内部類的變量和方法也沒有影響（？）。另外，就是要注意，内部類Inner及InnterTwo僅僅在類Outer的作用域内是可知的，假設類Outer外的不論什麼代碼嘗試初始化類Inner或使用它，編譯就不會通過。同一時候，内部類的變量成員僅僅在内部内内部可見，若外部類或同層次的内部類須要訪問。需採用示範樣例程式中的方法，不可直接訪問内部類的變量。