深入理解java嵌套類和內部類，深入理解java嵌套類

深入理解java嵌套類和內部類，深入理解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 = "josserchai@yahoo.com";//內部類公有成員  
7. 　　　　public void display(){  
8. 　　　　　　//System.out.println(id);//不能直接存取外部類的非靜態成員  
9. 　　　　　　System.out.println(name);//只能直接存取外部類的靜態成員  
10. 　　　　　　System.out.println("Inner "+address);//訪問本內部類成員。  
11. 　　　　}  
12. 　　}  
13.   
14. 　　public void printInfo(){  
15. 　　　　Person person = new Person();  
16. 　　　　person.display();  
17. 　　　　//System.out.println(mail);//不可訪問  
18. 　　　　//System.out.println(address);//不可訪問  
19. 　　　　System.out.println(person.address);//可以訪問內部類的私人成員  
20. 　　　　System.out.println(person.mail);//可以訪問內部類的公有成員  
21.   
22. 　　}  
23. 　　public static void main(String[] args) {  
24. 　　StaticTest staticTest = new StaticTest();  
25. 　　staticTest.printInfo();  
26. }  
27. }  

　　在靜態嵌套類內部，不能訪問外部類的非靜態成員，這是由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(){  
11. 　　　　　　　　System.out.println("display outer_x:"+ outer_x);  
12. 　　　　　　}  
13. 　　　　}  
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();  
24. 　　　　}  
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);//可以訪問  
35. 　　　　　　}  
36. 　　　　}  
37. 　　　　public static void main(String args[]){  
38. 　　　　　　Outer outer = new Outer();  
39. 　　　　　　outer.test();  
40. 　　　　}  
41. 　　}  

　　以上代碼需要說明有，對於內部類，通常在定義類的class關鍵字前不加public 或 private等限制符，若加了沒有任何影響，同時好像這些限定符對內部類的變數和方法也沒有影響（？）。另外，就是要注意，內部類Inner及InnterTwo只在類Outer的範圍內是可知的，如果類Outer外的任何代碼嘗試初始化類Inner或使用它，編譯就不會通過。同時，內部類的變數成員只在內部內內部可見，若外部類或同層次的內部類需要訪問，需採用樣本程式中的方法，不可直接存取內部類的變數。
JAVA內部類與嵌套類的應用

class A{
class Ainner{
class Inner{

}
}
}
使這個意思嗎
 
JAVA內部類嵌套問題

首先，你這樣ABC的動態嵌套肯定有嚴重誤用的嫌疑。。
如果要強行引用A的執行個體對象中成員，寫法是A.this.methodOfA();
即
public void fun() {
System.out.println(A.this.propertyX);
A.this.methodOfA();
}
如果內層類不是隨著外層類的執行個體對象的內容變化而變化，內層類要加static class C設為靜態類。可減少一個數量級的不必要的資源浪費。
如果內層類是公用的，被別的類調用很多或邏輯從屬關係不明顯，還要考慮不寫成內層類。單獨寫一個java檔案。