java內部類學習！！

今天有同學問了我一個問題引發了我對java內部類的研究。他的問題是這樣的，編寫了一個Stu類，這個類裡面有一個內部類Student，編譯的時候沒有任何問題，但是啟動並執行時候遇到了java.lang.NoSuchMethodError Student.setId()。但是這個Student類沒有任何問題，還有一個就是這個問題只在他的電腦上有，在別的電腦上運行沒有問題，於是定位是環境變數的classpath有問題。最後通過改變classpath把問題解決了，能夠運行不出錯了。

但是為什麼會出現這樣的錯誤呢，於是對java內部類做了一下研究。不過研究成果是參考別人的，人家的確寫得挺好，於是學習了。

友情提示一下：如果對java反射不熟悉的可以使用JD-GUI這個java反編譯軟體，他可以協助你直接通過反編譯產生的.class檔案產生java代碼，更有利於我們理解內部類和外部類之間的關係。

內部類有兩種情況：

(1) 在類中定義一個類(私人內部類，靜態內部類)

(2) 在方法中定義一個類(局部內部類，匿名內部類)

1、私人內部類 —— 在方法之間定義的內部類，非靜態

      我們首先看看類中內部類的兩個特點：

     (1) 在外部類的作用範圍內可以任意建立內部類對象，即使內部類是私人的(私人內部類)。即內部類對包圍它的外部類可見。

Java代碼 

1. //代碼1：內部類對外部類可見  
2. class Outer{  
3.      //建立私人內部類對象  
4.      public Inner in=new Inner();  
5.      //私人內部類  
6.      private class Inner{  
7.           ...  
8.      }  
9. }  

      (2) 在內部類中可以訪問其外部類的所有域，即使是私人域。即外部類對內部類可見。

Java代碼 

1. //代碼2：外部類對內部類可見  
2. class Outer{  
3.        //外部類私人資料域  
4.        private int data=0;  
5.        //內部類  
6.        class Inner{  
7.            void print(){  
8.                  //內部類訪問外部私人資料域  
9.                  System.out.println(data);  
10.            }   
11.        }  
12. }  

       問題來了：上面兩個特點到底如何辦到的呢？內部類的"內部"到底發生了什嗎？

      其實，內部類是Java編譯器一手操辦的。虛擬機器並不知道內部類與常規類有什麼不同。 編譯器是如何瞞住虛擬機器的呢？

     對內部類進行編譯後發現有兩個class檔案：Outer.class 和Outer$Inner.class 。這說明內部類Inner仍然被編譯成一個獨立的類(Outer$Inner.class)，而不是Outer類的某一個域。 虛擬機器啟動並執行時候，也是把Inner作為一種常規類來處理的。

        但問題來了，即然是兩個常規類，為什麼他們之間可以互相訪問私人域那(最開始提到的兩個內部類特點)？這就要問問編譯器到底把這兩個類編譯成什麼東西了。

        我們利用reflect反射機制來探查了一下內部類編譯後的情況（關於探查類內部機制的代碼提供在下面的附件裡Reflect.java）。

        (1)、編譯代碼1產生 Outer$Inner.class 檔案後使用 ReflectUtil.reflect("Outer$Inner") 對內部類Inner進行反射。運行結果 發現了三個隱含的成分：          

反編譯代碼 

1. //反編譯1  
2. class Outer$Inner  
3. {  
4.         Outer$Inner(Outer,Outer$Inner);  //包可見構造器  
5.         private Outer$Inner(Outer);   //私人構造器將設定this$0域  
6.         final Outer this$0;   //外部類執行個體域this$0  
7. }  

 

      好了，現在我們可以解釋上面的第一個內部類特點了： 為什麼外部類可以建立內部類的對象？並且內部類能夠方便的引用到外部類對象?

     首先編譯器將外、內部類編譯後放在同一個包中。在內部類中附加一個包可見構造器。這樣， 虛擬機器運行Outer類中Inner in=new Inner(); 實際上調用的是包可見構造： new Outer$Inner(this,null)。因此即使是private內部類，也會通過隱含的包可見構造器成功的獲得私人內部類的構造許可權。

      再者，Outer$Inner類中有一個指向外部類Outer的引用this$0，那麼通過這個引用就可以方便的得到外部類對象中可見成員。但是Outer類中的private成員是如何訪問到的呢？這就要看看下面Outer.class檔案中的秘密了。

      (2)、編譯代碼2產生 Outer.class檔案，然後使用 ReflectUtil.reflect("Outer") 對外部類Outer進行反射 。 運行結果 發現一個隱含成分如下：

反編譯代碼 

1. //反編譯2  
2. class Outer  
3. {  
4.           static int access$0(Outer);  //靜態方法，傳回值是外部類私人域 data 的值。  
5. }  

     

      現在可以解釋第二個特點了：為什麼內部類可以引用外部類的私人域？

         原因的關鍵就在編譯器在外圍類中添加了靜態方法access$0。 它將傳回值作為參數傳遞給他的對象域data。這樣內部類Inner中的列印語句：

                     System.out.println(data);

         實際上啟動並執行時候調用的是：

                 S ystem.out.println(this$0.access$0(Outer));

總結一下編譯器對類中內部類做的手腳吧：

(1)  在內部類中偷偷摸摸的建立了包可見構造器，從而使外部類獲得了建立許可權。

(2)  在外部類中偷偷摸摸的建立了訪問私人變數的靜態方法，從而 使 內部類獲得了存取權限。

這樣，類中定義的內部類無論私人，公有，靜態都可以被包圍它的外部類所訪問。

2、靜態內部類  ——  在方法間定義的內部類，靜態

     內部類也有靜態區別，這就是靜態內部類，我們來看看代碼：

Java代碼 

1. package hr.test;  
2. //代碼3：靜態內部類對外部變數的引用  
3. public class Outer{    
4.         private static int i=0;          
5.         //建立靜態內部類對象  
6.     public Inner in=new Inner();    
7.     //靜態  
8.     private static class Inner{    
9.         public void print(){  
10.                          System.out.println(i);   //如果i不是靜態變數，這裡將無法通過編譯。  
11.                 }  
12.     }    
13.   
14. }    

       靜態內部類和私人內部類最大的區別在於，靜態內部類中無法引用到其外圍類的非靜態成員。這是為什嗎？我們還是來看看靜態內部類Outer$Inner中發生了什麼吧？

反編譯代碼 

1. //反編譯3  
2. class Outer$Inner  
3. {  
4.       private Outer$Inner();  
5.       Outer$Inner(hr.test.Outer$Inner);  
6. }  

        與上面私人內部類反編譯1比較發現，少了一個指向外圍類對象的引用final Outer this$0; 也就是說靜態內部類無法得到其外圍類對象的引用，那麼自然也就無法訪問外圍類的非靜態成員了。因此，靜態內部類只能訪問其外圍類的靜態成員，除此之外與非靜態內部類沒有任何區別。

3、局部內部類 —— 在方法中定義的內部類

      方法內部類也有兩個特點

      (1)  方法中的內部類沒有存取修飾詞， 即方法內部類對包圍它的方法之外的任何東西都不可見。

      (2)  方法內部類只能夠訪問該方法中的局部變數，所以也叫局部內部類。而且這些局部變數一定要是final修飾的常量。

Java代碼 

1. class Outter{  
2.       public void outMethod(){  
3.              final int beep=0;  
4.              class Inner{  
5.                    //使用beep  
6.              }  
7.              Inner in=new Inner();  
8.       }  
9. }  

 

      這又是為什麼呢？

      (1) 我們首先對Outter類進行反射發現，Outter中再也沒有返回私人域的隱藏方法了。

      (2) 對Inner類的反射發現，Inner類內部多了一個對beep變數的備份隱藏欄位：final int val$i;

      我們可以這樣解釋Inner類中的這個備份常量域，首先當JVM運行到需要建立Inner對象之後，Outter類已經全部運行完畢，這是記憶體回收機制很有可能釋放掉局部變數beep。那麼Inner類到哪去找beep變數呢？

      編譯器又出來幫我們解決了這個問題，他在Inner類中建立了一個beep的備份 ，也就是說即使Ouuter中的beep被回收了，Inner中還有一個備份存在，自然就不怕找不到了。

      但是問題又來了。如果Outter中的beep不停的在變化那。那豈不是也要讓備份的beep變數無時無刻的變化。為了保持局部變數與局部內部類中備份域保持一致。 編譯器不得不規定死這些局部域必須是常量，一旦賦值不能再發生變化了。

      所以為什麼局部內部類應用外部方法的域必須是常量域的原因所在了。

內部類的特點總結

(1)  在方法間定義的非靜態內部類： 

       ● 外圍類和內部類可互相訪問自己的私人成員。

       ● 內部類中不能定義靜態成員變數。

(2) 在方法間定義的靜態內部類：

       ● 只能訪問外部類的靜態成員。

(3) 在方法中定義的局部內部類：

       ● 該內部類沒有任何的存取控制許可權

       ● 外圍類看不見方法中的局部內部類的，但是局部內部類可以訪問外圍類的任何成員。

       ● 方法體中可以訪問局部內部類，但是訪問語句必須在定義局部內部類之後。

       ● 局部內部類只能存取方法體中的常量，即用final修飾的成員。

(4) 在方法中定義的匿名內部類：

       ● 沒有構造器，取而代之的是將構造器參數傳遞給超類構造器。