Java內部類

標籤：

1.內部類        

首先舉一個簡單的例子，如果你想實現一個介面，但是這個介面中的一個方法和你構想的這個類中的一個 方法的名稱，參數相同，你應該怎麼辦？這時候，你可以建一個內部類實現這個介面。由於內部類對外部類的所有內容都是可訪問的，所以這樣做可以完成所有你直 接實現這個介面的功能。
         不過你可能要質疑，更改一下方法的不就行了嗎？
        的確，以此作為設計內部類的理由，實在沒有說服 力。
        真正的原因是這樣的，java中的內部類和介面加在一起，可以的解決常被C++程式員抱怨java中存在的一個問題——沒有多繼承。實際上，C++的多繼承設計起來很複雜，而java通過內部類加上介面，可以很好的實現多繼承的效果。
        內部類：一個內部類的定義是定義在另一個內部的類。
原因是：
1.一個內部類的對象能夠訪問建立它的對象的實現，包括私人資料。
2. 對於同一個包中的其他類來說，內部類能夠隱藏起來。
3.匿名內部類可以很方便的定義回調。
4.使用內部類可以非常方便的編寫事件驅動程式

       內部類可以讓你更優雅地設計你的程式結構。下面從以下幾個方面來介紹：

 第一次見面 [java] view plaincopyprint? 

1. public interface Contents {  
2. 　int value();  
3. }  
4.   
5. public interface Destination {  
6. 　String readLabel();  
7. }  

 

[java] view plaincopyprint? 

1. public class Goods {  
2. 　private class Content implements Contents {  
3. 　　 private int i = 11;  
4. 　　public int value() {  
5. 　　　return i;  
6. 　　}  
7. 　 }  
8.   
9. 　protected class GDestination implements Destination {  
10. 　　 private String label;  
11. 　　private GDestination(String whereTo) {  
12. 　　　 label = whereTo;  
13. 　　}  
14. 　　public String readLabel() {  
15. 　　　return label;  
16. 　　}  
17. 　}  
18.   
19. 　public Destination dest(String s) {  
20. 　　 return new GDestination(s);  
21. 　}  
22.   
23. 　public Contents cont() {  
24. 　　 return new Content();  
25. 　}  
26. }  
27.   
28. class TestGoods {  
29. 　public static void main(String[] args) {  
30. 　　Goods p = new Goods();  
31. 　　 Contents c = p.cont();  
32. 　　Destination d = p.dest("Beijing");  
33.     }  
34. }  

        在這個例子裡類 Content 和 GDestination 被定義在了類 Goods 內部，並且分別有著 protected 和 private 修飾符來控制存取層級。Content 代表著 Goods 的內容，而 GDestination 代表著 Goods 的目的地。它們分別實現了兩個介面Content和Destination。在後面的main方法裡，直接用 Contents c 和 Destination d進行操作，你甚至連這兩個內部類的名字都沒有看見！這樣，內部類的第一個好處就體現出來了——隱藏你不想讓別人知道的操作，也即封裝性。

       同時，我們也發現了在外部類作用範圍之外得到內部類對象的第一個方法，那就是利用其外部類的方法建立並返回。上例中的cont()和 dest() 方法就是這麼做的。那麼還有沒有別的方法呢？當然有，其文法格式如下：

[java] view plaincopyprint? 

1. outerObject=new outerClass(Constructor Parameters);  
2. outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);  

       注意在建立非靜態內部類對象時，一定要先建立起相應的外部類對象。至於原因，也就引出了我們下一個話題——

  非靜態內部類對象有著指向其外部類對象的引用

 修改上面的例子

[java] view plaincopyprint? 

1. public class Goods {  
2. 　 private valueRate=2;  
3.   
4. 　private class Content implements Contents {  
5. 　  private int i = 11 * valueRate;  
6. 　　public int value() {  
7. 　　　return i;  
8. 　　}  
9. 　}  
10.   
11. 　protected class GDestination implements Destination {  
12. 　　private String label;  
13. 　　private GDestination(String whereTo) {  
14. 　　　label = whereTo;  
15. 　　}  
16. 　　public String readLabel() {  
17. 　　　return label;  
18. 　　}  
19. 　}  
20.   
21. 　public Destination dest(String s) {  
22. 　　return new GDestination(s);  
23. 　}  
24.   
25. 　 public Contents cont() {  
26. 　　return new Content();  
27. 　}  
28. }  

        在這裡我們給 Goods 類增加了一個 private 成員變數 valueRate，意義是貨物的價值係數，在內部類 Content 的方法 value() 計算價值時把它乘上。我們發現，value() 可以訪問 valueRate，這也是內部類的第二個好處——一個內部類對象可以訪問建立它的外部類對象的內容，甚至包括私人變數！這是一個非常有用的特性，為我們在設計時提供了更多的思路和捷徑。要想實現這個功能，內部類對象就必須有指向外部類對象的引用。Java 編譯器在建立內部類對象時，隱式的把其外部類對象的引用也傳了進去並一直儲存著。這樣就使得內部類對象始終可以訪問其外部類對象，同時這也是為什麼在外部 類作用範圍之外向要建立內部類對象必須先建立其外部類對象的原因。（具體原因見：http://blog.csdn.net/yu422560654/article/details/6978981）

        有人會問，如果內部類裡的一個成員變數與外部類的一個成員變數同名，也即外部類 的同名成員變數被屏蔽了，怎麼辦？沒事，Java裡用如下格式表達外部類的引用：
        outerClass.this
        有了它，我們就不怕這種屏蔽的情況了。

 

靜態內部類（嵌套類）

        和普通的類一樣，內部類也可以有靜態。不過和非靜態內部類相比，區別就在於靜態內部類沒有了指向外部的引用。這實際上和 C++ 中的嵌套類很相像了，Java 內部類與 C++ 嵌套類最大的不同就在於是否有指向外部的引用這一點上，當然從設計的角度以及以它一些細節來講還有區別。
        除此之外，在任何非靜態內部類中，都不能有待用資料，靜態方法或者又一個靜態內部類（內部類的嵌套可以不止一層）。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。

 

局部內部類

        是的，Java 內部類也可以是局部的，它可以定義在一個方法甚至一個代碼塊之內。

[java] view plaincopyprint? 

1. public class Goods1 {  
2. 　public Destination dest(String s) {  
3. 　　class GDestination implements Destination {  
4. 　　　private String label;  
5. 　　　private GDestination(String whereTo) {  
6. 　　　　label = whereTo;  
7. 　　　}  
8. 　　　 public String readLabel() { return label; }  
9. 　　}  
10.   
11. 　　return new GDestination(s);  
12. 　}  
13.   
14. 　public static void main(String[] args) {  
15. 　 　Goods1 g= new Goods1();  
16. 　　Destination d = g.dest("Beijing");  
17. 　}  
18. }  

        上面就是這樣一個例子。在方法dest中我們定義了一個內部類，最後由這個方法返回這個內部類的對象。如果我們在用一個內部類的時候僅需要建立它的一個對象並傳給外部，就可以這樣做。當然，定義在方法中的內部類可以使設計多樣化，用途絕不僅僅在這一點。

        下面有一個更怪的例子：

[java] view plaincopyprint? 

1. public class Goods2{  
2. 　private void internalTracking(boolean b) {  
3. 　　if(b) {  
4. 　　　class TrackingSlip {  
5. 　　　　private String id;  
6. 　　　　 TrackingSlip(String s) {  
7. 　　　　　id = s;  
8. 　　　　}  
9. 　　　　String getSlip() { return id; }  
10. 　　　}  
11. 　　　TrackingSlip ts = new TrackingSlip("slip");  
12. 　　　String s = ts.getSlip();  
13. 　　}  
14. 　}  
15.   
16. 　 public void track() { internalTracking(true); }  
17.   
18. 　public static void main(String[] args) {  
19. 　　Goods2 g= new Goods2();  
20. 　　g.track();  
21. 　 }  
22. }  

        你不能在 if 之外建立這個內部類的對象，因為這已經超出了它的範圍。不過在編譯的時候，內部類 TrackingSlip和其他類一樣同時被編譯，只不過它由它自己的範圍，超出了這個範圍就無效，除此之外它和其他內部類並沒有區別。

 

2. 匿名類

        匿名類是不能有名稱的類，所以沒辦法引用他們。必須在建立時，作為new語句的一部分來聲明他們。 
這就要採用另一種形式 的new語句，如下所示： 

        new <類或介面> <類的主體>

        這種形式的new語句聲明一個 新的匿名類，他對一個給定的類進行擴充，或實現一個給定的介面。他還建立那個類的一個新執行個體，並把他作為語句的結果而返回。要擴充的類和要實現的介面是 new語句的運算元，後跟匿名類的主體。 
假如匿名類對另一個類進行擴充，他的主體能夠訪問類的成員、覆蓋他的方法等等，這和其他任何標準的類都 是相同的。假如匿名類實現了一個介面，他的主體必須實現介面的方法。

        注意匿名類的聲明是在編譯時間進行的，執行個體化在運行時進行。這意味著 for迴圈中的一個new語句會建立相同匿名類的幾個執行個體，而不是建立幾個不同匿名類的一個執行個體。

        從技術上說，匿名類可被視為非靜態內 部類，所以他們具備和方法內部聲明的非靜態內部類相同的許可權和限制。

        假如要執行的任務需要一個對象，但卻不值得建立全新的對象（原因可能 是所需的類過於簡單，或是由於他只在一個方法內部使用），匿名類就顯得很有用。匿名類尤其適合在Swing應用程式中快速建立事件處理程式。

[java] view plaincopyprint? 

1. interface pr {   
2. 　void print1();   
3. }  
4.   
5. public class noNameClass {   
6. 　public pr dest() {   
7. 　　return new pr() {   
8. 　　　 public void print1() {   
9. 　　　　System.out.println("Hello world!!");   
10. 　 　　}   
11. 　　};  
12. 　}  
13. }  
14.   
15. public static void main(String args[]) {   
16. 　 noNameClass c = new noNameClass();  
17. 　pr hw = c.dest();  
18. 　 hw.print1();  

Java內部類