剖析內部類如何實現的

內部類有兩種情況：

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

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

 

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

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

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

//代碼1：內部類對外部類可見
class Outer{
     //創建私有內部類對象
     public Inner in=new Inner();
     //私有內部類
     private class Inner{
          ...
     }
}

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

//代碼2：外部類對內部類可見
class Outer{
       //外部類私有數據域
       private int data=0;
       //內部類
       class Inner{
           void print(){
                 //內部類訪問外部私有數據域
                 System.out.println(data);
           }
       }
}

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

 

 

      其實，內部類是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
class Outer$Inner
{
        Outer$Inner(Outer,Outer$Inner);  //包可見構造器
        private Outer$Inner(Outer);   //私有構造器將設置this$0域
        final Outer this$0;   //外部類實例域this$0
}

 

 

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

     首先編譯器將外、內部類編譯後放在同一個包中。在內部類中附加一個包可見構造器。這樣， 虛擬機運行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進行反射 。 運行結果 發現一個隱含成分如下：

//反編譯2
class Outer
{
          static int access$0(Outer);  //靜態方法，返回值是外部類私有域 data 的值。
}

     

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

 

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

                     System.out.println(data);

         實際上運行的時候調用的是：

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

 

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

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

(2)  在外部類中偷偷摸摸的創建了訪問私有變量的靜態方法，從而 使 內部類獲得了訪問權限。

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

 

 

 

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

 

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

package hr.test;
//代碼3：靜態內部類對外部變量的引用
public class Outer{
        private static int i=0;
        //創建靜態內部類對象
    public Inner in=new Inner();
    //靜態
    private static class Inner{
        public void print(){
                         System.out.println(i);   //如果i不是靜態變量，這裏將無法通過編譯。
                }
    }

}

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

//反編譯3
class Outer$Inner
{
      private Outer$Inner();
      Outer$Inner(hr.test.Outer$Inner);
}

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

 

 

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

      方法內部類也有兩個特點

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

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

class Outter{
      public void outMethod(){
             final int beep=0;
             class Inner{
                   //使用beep
             }
             Inner in=new Inner();
      }
}

 

      這又是爲什麼呢？

      (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) 在方法中定義的匿名內部類：

public class ReflectUtil {

	public static void reflect(String cName){
		try{
			Class c=Class.forName(cName);
			Class superc=c.getSuperclass();
			System.out.print("class "+c.getName());
			if(superc!=null&&superc!=Object.class)
				System.out.print(" extends"+superc.getName());

			System.out.print("\n{\n");
			printConstructors(c);
			System.out.println();
			printMethods(c);
			System.out.println();
			printFields(c);
			System.out.println("}");
			
		}catch(ClassNotFoundException e){
			e.printStackTrace();
		}
		System.exit(0);
	}

	private static void printConstructors(Class cl)
	{
		Constructor[] constructors=cl.getDeclaredConstructors();
		
		for(Constructor c:constructors)
		{
			String name=c.getName();
			System.out.print("   "+Modifier.toString(c.getModifiers()));
			System.out.print(" "+name+"(");

			Class[] paramTypes=c.getParameterTypes();
			for(int j=0;j<paramTypes.length;j++)
			{
				if(j>0) System.out.print(",");
				System.out.print(paramTypes[j].getName());
			}
			System.out.println(");");
		}
	}

	private static void printMethods(Class cl)
	{
		Method[] methods=cl.getDeclaredMethods();

		for(Method m:methods)
		{
			Class retType=m.getReturnType();
			String name=m.getName();
			System.out.print("   "+Modifier.toString(m.getModifiers()));
			System.out.print(" "+retType.getName()+" "+name+"(");

			Class[] paramTypes=m.getParameterTypes();
			for(int j=0;j<paramTypes.length;j++)
			{
				if(j>0) System.out.print(",");
				System.out.print(paramTypes[j].getName());

			}
			System.out.println(");");

		}
	}

	private static void printFields(Class c)
	{
		Field[] fields=c.getDeclaredFields();

		for(Field f:fields)
		{
			Class type=f.getType();
			String name=f.getName();
			System.out.print("   "+Modifier.toString(f.getModifiers()));
			System.out.println(" "+type.getName()+" "+name+";");
		}

	}

}

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