內部類

定義：一個定義在類內部的類。之所以用內部類是因為使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（介面的）實現，所以無論外圍類是否已經繼承了某個（介面的）實現，對於內部類都沒有影響。可以這樣說，介面只是解決了部分問題，而內部類使得多重繼承的解決方案變得更加完整。

內部類：內部類可以有多個例項，每個例項都有自己的狀態資訊，並且與其他外部物件的資訊相互獨立。在單個外部類中，可以讓多個內部類以不同的方式實現同一個介面，或者繼承同一個類。建立內部類物件的時刻並不依賴於外圍類物件的建立。內部類並沒有令人迷惑的“is-a”關係，他就是一個獨立的實體。內部類提供了更好的封裝，除了該外圍類，其他類都不能訪問。內部類與外部類建立一種關係，可以訪問外部類包括私有的屬性。引用內部類首先建立內部類物件要用外部類物件來建立，OuterClass.InnerClass innerClass = outerClass.new InnerClass();內部類與外部類是編譯時的概念，編譯之後就是兩個不同的class檔案，內部類分為成員內部類，區域性內部類、匿名內部類、靜態內部類。

成員內部類：：1）成員內部類中不能存在任何static的變數和方法；2）成員內部類是依附於外圍類的，所以只有先建立了外圍類才能夠建立內部類。

1. publicclass Outer {  
2.     private String str;  
3.     publicvoid outerDisplay(){  
4.         System.out.println("outer");  
5.     }    
6.     publicclass InnerClass{  
7.         publicvoid innerDisplay(){             
8.             str = "ch";  
9.             System.out.println(str);           
10.             outerDisplay();  
11.         }  
12.     }  
13.     public InnerClass getInnerClass(){  
14.         returnnew InnerClass();  
15.     }   
16.     publicstaticvoid main(String[] args) {  
17.         Outer  outer = new Outer();  
18.         Outer.InnerClass inner = outer.getInnerClass();  
19.         inner.innerDisplay();  
20.     }  
21. }  

匿名內部類：Swing程式設計中，我們經常使用這種方式來繫結事件，

1. button2.addActionListener(    
2.                 new ActionListener(){    
3.                     publicvoid actionPerformed(ActionEvent e) {    
4.                         System.out.println("你按了按鈕二");    
5.                     }    
6.                 });  

使用匿名內部類我們必須要繼承一個父類或者實現一個介面，當然也僅能只繼承一個父類或者實現一個介面。同時它也是沒有class關鍵字，這是因為匿名內部類是直接使用new來生成一個物件的引用。當然這個引用是隱式的。匿名內部類的使用它是存在一個缺陷的，就是它僅能被使用一次。建立匿名內部類時它會立即建立一個該類的例項，該類的定義會立即消失，所以匿名內部類是不能夠被重複使用，匿名內部類為區域性內部類，所以區域性內部類的所有限制同樣對匿名內部類生效。：匿名內部類不能是抽象的，它必須要實現繼承的類或者實現的介面的所有抽象方法。

當所在的方法的形參需要被內部類裡面使用時，該形參必須為final。內部類並不是直接呼叫方法傳遞的引數，而是利用自身的構造器對傳入的引數進行備份，自己內部方法呼叫的實際上時自己的屬性而不是外部方法傳遞進來的引數。內部類中我對屬性的改變並不會影響到外部的形參，所以為了保持引數的一致性，就規定使用final來避免形參的不改變。匿名內部類沒有構造器，使用構造程式碼塊達到創造一個構造器的效果。
靜態內部類：非靜態內部類在編譯完成之後會隱含地儲存著一個引用，該引用是指向建立它的外部類，但是靜態內部類卻沒有。沒有這個引用就意味著：它的建立是不需要依賴於外部類的。2）它不能使用任何外圍類的非static成員變數和方法。

1. publicclass Outer {  
2.     private String sex;  
3.     publicstatic String name = "che";  
4.     staticclass InnerClass1{  
5.         /* 在靜態內部類中可以存在靜態成員 */
6.         publicstatic String _name1 = "che_static";         
7.         publicvoid display(){  
8.             /*  
9.              * 靜態內部類只能訪問外圍類的靜態成員變數和方法 
10.              * 不能訪問外圍類的非靜態成員變數和方法 
11.              */
12.             System.out.println("OutClass name :" + name);  
13.         }  
14.     }  
15.     class InnerClass2{  
16.         /* 非靜態內部類中不能存在靜態成員 */
17.         public String _name2 = "che_inner";  
18.         /* 非靜態內部類中可以呼叫外圍類的任何成員,不管是靜態的還是非靜態的 */
19.         publicvoid display(){  
20.             System.out.println("OuterClass name：" + name);  
21.         }  
22.     }  
23.     publicvoid display(){  
24.         /* 外圍類訪問靜態內部類：內部類. */
25.         System.out.println(InnerClass1._name1);  
26.         /* 靜態內部類 可以直接建立例項不需要依賴於外圍類 */
27.         new InnerClass1().display();  
28.         /* 非靜態內部的建立需要依賴於外圍類 */
29.         Outer.InnerClass2 inner2 = new Outer().new InnerClass2();  
30.         /* 方位非靜態內部類的成員需要使用非靜態內部類的例項 */
31.         System.out.println(inner2._name2);  
32.         inner2.display();  
33.     }    
34.     publicstaticvoid main(String[] args) {  
35.         Outer outer = new Outer();  
36.         outer.display();  
37.     }  
38. }  

多重繼承的實現

一個類可以同時從多個類繼承行為和屬性，java只支援單繼承，那麼實現多重繼承的方式有介面和內部類。

介面實現：介面和抽象類的時候瞭解到子類只能繼承一個父類，也就是說只能存在單一繼承，但是卻可以實現多個介面，介面是沒有任何具體實現的，也就是說，沒有任何與介面相關的儲存。

1. interface CanFight {  
2.     void fight();  
3. }  
4. interface Swim {  
5.     void swim();  
6. }  
7. interface Fly {  
8.     void fly();  
9. }  
10. publicclass Action {  
11.     publicvoid fight(){  
12.     }  
13. }  
14. publicclass Hero extends Action implements Fight,Fly,Swim{  
15.     publicvoid fly() {  
16.     }  
17.     publicvoid swim() {  
18.     }  
19.     /** 
20.      * 對於fight()方法，繼承父類的，所以不需要顯示宣告 
21.      */
22. }  

如果父類為抽象類或者具體類，那麼我就僅能通過內部類來實現多重繼承了。

1. class Father {  
2.     publicint str(){  
3.         return2;  
4.     }  
5. }  
6. class Mother {  
7.     publicint can(){  
8.         return2;  
9.     }  
10. }  
11.  class Son {  
12.     class Father_1 extends Father{  
13.         publicint str(){  
14.             returnsuper.str() + 1;  
15.         }  
16.     }   
17.     class Mother_1 extends  Mother{  
18.         publicint can(){  
19.             returnsuper.can() - 2;  
20.         }  
21.     }    
22.     publicint get(){  
23.         returnnew Father_1().str();  
24.     }    
25.     publicint getcan(){  
26.         returnnew Mother_1().can();  
27.     }  
28. }  
29. publicclass Outer {  
30.     publicstaticvoid main(String[] args) {  
31.         Son son = new Son();  
32.         System.out.println( son.get());  
33.         System.out.println( son.getcan());  
34.     }  
35. }