java內部類

標籤：

在Java中，可以將一個類定義在另一個類裡面或者一個方法裡面，這樣的類稱為內部類。內部類仍然是一個獨立的類，在編譯之後內部類會被編譯成獨立的.class檔案，但是前面冠以外部類的類名和$符號。內部類可以間接解決多繼承問題,可以使用內部類繼承一個類，外部類繼承一個類，實現多繼承。       內部類主要分為成員內部類，方法內部類，靜態內部類,匿名內部類。

 

1.成員內部類    成員內部類顧名思義就是外部類的一個成員屬性，只不過該屬性不是String，int等類型，而是class類型。類的成員內部類可以訪問該類的屬性和方法，因為他也是該類的一個成員。   成員內部類使用：

1. package com.dream;  
2.   
3. public class MyTest {  
4.   
5.     public static void main(String[] args) {  
6.   
7.         Mother mother=new Mother(12, "小明");  
8.           
9.         //執行個體內部類的方法之一  
10.         Mother.baby temp=mother.new baby();       
11.         temp.say();  
12.           
13.         //執行個體化方法二，通過調用類的成員函數訪問內部類  
14.         mother.say();  
15.           
16.     }  
17.   
18. }  
19.   
20. class Mother{  
21.       
22.     private int age;  
23.   
24.     public String name;  
25.   
26.     public Mother(int age, String name) {  
27.           
28.         this.age = age;  
29.         this.name = name;  
30.     }  
31.       
32.     //定義內部類(成員內部類）  
33.     class baby{  
34.         public void say()  
35.         {  
36.             System.out.println("我已經"+age+"歲啦，名字叫"+name);  
37.         }  
38.     }  
39.       
40.     //在類中執行個體化  
41.     public void say()  
42.     {  
43.         baby temp=new baby();  
44.         temp.say();  
45.     }  
46.       
47. }  

複製代碼成員內部類是類的一個成員，類的成員依賴類對象，所以內部類也依賴於對象，類需要執行個體化才能使用,所以使用外部類對象來執行個體化內部類。

 

2.方法內部類顧名思義方法內部類即把類定義在方法裡面，需要注意的是：    1.方法內部類只能在定義該內部類的方法裡執行個體化，不可在此方法之外地方對其執行個體化    2.方法內部類對象不能使用該內部類所在方法的非final屬性

1. public class MyTest {  
2.     public void say(final String name)  
3.     {   //方法內部類  
4.         class baby  
5.         {         
6.             public void say()  
7.             {  
8.                 //需要final屬性  
9.                 System.out.println("名字叫"+name);  
10.             }  
11.               
12.         }  
13.           
14.         //在該方法內部執行個體化  
15.         baby temp=new baby();  
16.         temp.say();  
17.     }  
18.   
19.     public static void main(String[] args) {  
20.               
21.             MyTest  test=new MyTest();  
22.              test.say("王小帥");  
23.               
24.     }  
25.   
26. }  

複製代碼方法內部類的範圍局限於該方法內，所以要在方法內執行個體化。方法內定義的變數是局部變數，離開該方法，變數就失去了作用，也就會自動被消除，而內部類卻不會離開它所在方法就失去作用，它有更廣的生命週期，所以需要拷貝到內部類中，而拷貝會帶來不一致性，從而需要使用final聲明保證一致性。

 

3.靜態內部類即在一個類裡定義一個靜態內部類，靜態就是該內部類可以像其他靜態成員一樣，沒有執行個體的外部類對象也可以訪問調用，靜態屬性不屬於類的執行個體對象。

1. public class MyTest {  
2.       
3.     public int age=1;  
4.       
5.     public static String name="小黑";  
6.     //定義靜態內部類  
7.     static class baby{  
8.           
9.         public void say()  
10.         {  
11.             //不能訪問age屬性，只能訪問靜態屬性  
12.             System.out.println("name: "+name);  
13.         }  
14.           
15.     }  
16.   
17.     public static void main(String[] args) {      
18.         //執行個體化靜態內部類  
19.         MyTest.baby temp=new MyTest.baby();  
20.         temp.say();  
21.     }  
22.   
23. }  

複製代碼   需要注意的是靜態內部類只能訪問外部類中的靜態成員屬性和方法，因為靜態屬性可以不使用外部執行個體對象進行訪問，若屬性不是靜態屬性，則需要依賴於外部類的執行個體對象。所以靜態內部類只能訪問外部類的靜態屬性

 

4.匿名內部類    匿名內部類有點像匿名對象，沒有名字，只能使用一次，匿名內部類又分三種情況1.繼承式匿名內部類：可以不定義class去繼承該抽象類別而實現抽象類別的執行個體和運行

1. public class MyTest {  
2.       
3.     public static void main(String[] args) {      
4.           
5.         //相當繼承Mother類並實現抽象方法  
6.         Mother mother=new Mother(25, "桂綸鎂"){  
7.             public void say()  
8.             {  
9.                 System.out.println("age: "+age+"  name: "+name);  
10.             }  
11.         };  
12.         mother.say();  
13.           
14.     }  
15.   
16. }  
17.   
18. abstract class Mother{  
19.       
20.     public int age;  
21.   
22.     public String name;  
23.   
24.     public Mother(int age, String name) {  
25.           
26.         this.age = age;  
27.         this.name = name;  
28.     }  
29.       
30.     public abstract void say();  
31. }  

複製代碼

2.介面式匿名內部類：可以不定義class去實現該介面而實現介面的調用

1. public class MyTest {  
2.       
3.     public static void main(String[] args) {      
4.           
5.         //相當於實現介面  
6.         baby temp=new baby() {        
7.             @Override  
8.             public void say() {  
9.                 System.out.println("name： "+name);  
10.             }  
11.         };  
12.         temp.say();  
13.           
14.     }  
15.   
16. }  
17.   
18. interface baby{  
19.       
20.   String name="小黑";//介面定義的屬性都是常量，修飾為 public final static String name  
21.   public void say();  
22. }  

複製代碼

3.參數式匿名內部類：只能訪問final屬性

1. public class MyTest {  
2.   
3.     public void say(baby temp)  
4.     {  
5.         temp.say();  
6.     }  
7.       
8.     public static void main(String[] args) {      
9.           
10.         MyTest test=new MyTest();  
11.           
12.         final int age=10;  
13.         //參數匿名內部類  
14.         test.say(new baby() {  
15.                           
16.             @Override  
17.             public void say() {  
18.                 //要訪問final定義的屬性  
19.                 System.out.println("age: "+age);  
20.                   
21.             }  
22.         });  
23.     }  
24.   
25. }  
26.   
27. interface baby{   
28.     String name="小黑";//介面定義的屬性都是常量，修飾為 public final static String name  
29.     public void say();  
30. }  

複製代碼說明為什麼要使用final屬性主要是局部變數的生命週期與局部內部類的對象的生命週期的不一致。

 

   內部類裡面使用外部類的局部變數時，其實就是內部類的對象在使用它，內部類對象生命週期中都可能調用它，而內部類試圖訪問外部方法中的局部變數時， 外部方法的局部變數很可能已經不存在了，那麼就得延續其生命，拷貝到內部類中，而拷貝會帶來不一致性，從而需要使用final聲明保證一致性。  複製保證生命週期延續，final保證引用一致。

java內部類