Java類初始化和執行個體化中的2個“雷區”_java

在考慮類初始化時，我們都知道進行子類初始化時，如果父類沒有初始化要先初始化子類。然而事情並沒有一句話這麼簡單。
首先看看Java中初始化觸發的條件：

（1）在使用new執行個體化對象，訪問待用資料和方法時，也就是遇到指令：new，getstatic/putstatic和invokestatic時；
（2）使用反射對類進行調用時；
（3）當初始化一個類時，父類如果沒有進行初始化，先觸發父類的初始化；
（4）執行入口main方法所在的類；
（5）JDK1.7動態語言支援中方法控制代碼所在的類，如果沒有初始化觸發起初始化；

經過編譯後產生一個<clinit>方法，類的初始化就在這個方法中進行，該方法只執行，由JVM保證這一點，並進行同步控制；
其中條件（3），從方法調用的角度來看，是子類的<clinit>會在開始時遞迴的調用父類的<clinit>，這類似與我們在子類構造器中必須首先調用父類的構造器；
但需要注意的是“觸發”並不是完成初始化，這意味著有可能子類的初始化會提前於父類初始化結束，這就是“危險”的所在。

1. 一個類初始化的例子：
這個例子我使用一個外圍類包含2個有繼承關係的靜態成員類，因為外圍類的初始化和靜態成員類沒有因果關係，因此這樣展示是安全和方便的；
父類A和子類B分別包含main函數，由上面的觸發條件（4）可知，通過分別調用這個兩個main函數來觸發不同的類初始化路徑；
這個例子的問題在於父類包含子類的static引用並在定義處進行初始化的問題：

public class WrapperClass {   private static class A {     static {       System.out.println("類A初始化開始...");     }     //父類包含子類的static引用     private static B b = new B();     protected static int aInt = 9;      static {       System.out.println("類A初始化結束...");     }      public static void main(String[] args) {      }   }    private static class B extends A {     static {       System.out.println("類B初始化開始...");     }     //子類的域依賴於父類的域     private static int bInt = 9 + A.aInt;      public B() {       //構造器依賴類的static域       System.out.println("類B的構造器調用 " + "bInt的值" + bInt);     }      static {       System.out.println("類B初始化結束... " + "aInt的值：" + bInt);     }      public static void main(String[] args) {      }   } } 

情景一：入口為類B的main函數時輸出結果：

/**    * 類A初始化開始...    * 類B的構造器調用 bInt的值0    * 類A初始化結束...    * 類B初始化開始...    * 類B初始化結束... aInt的值：18    */ 

分析：可以看到，main函數的調用觸發了類B的初始化，進入類B的<clinit>方法，類A作為其父類先開始初始化進入了A的<clinit>方法，其中有一個語句new B();這時會進行B的執行個體化，這是已經在類B的<clinit>中了，main線程已經獲得鎖開始執行類B的<clinit>，我們開頭說過JVM會保證一個類的初始化方法只被執行一次，JVM收到new指令後不會再進入類B的<clinit>方法而是直接進行執行個體化，但是此時類B還沒有完成類初始化，所以可以看到bInt的值為0（這個0是類載入中準備階段分配方法區記憶體後進行的置零初始化）；
因此，可以得出，再父類中包含子類類型的static域並進行賦值動作，會可能導致子類執行個體化在類初始化完成前進行；

情景二：入口為類A的main函數時輸出結果：

/**    * 類A初始化開始...    * 類B初始化開始...    * 類B初始化結束... aInt的值：9    * 類B的構造器調用 bInt的值9    * 類A初始化結束...    */ 

分析：經過情景一的分析，我們知道，由類B的初始化觸發類A的初始化，會導致類A中類變數b的執行個體化在類B初始化完成前進行，那如果先初始化類A是不是就可以在類變數執行個體化的時候先觸發類B的初始化，從而使得初始化在執行個體化前呢？答案是肯定的，但是這仍然有問題。
根據輸出，可以看到，類B的初始化在類A的初始化完成前進行了，這導致了像類變數aInt的變數在類B初始化完成後才進行初始化，所以類B中的域bInt擷取到的aInt的值是“0”，而不是我們預期的“18”；

結論：綜上，可以得出，在父類中包含子類類型的類變數，並在定義出進行執行個體化是非常危險的行為，具體情況可能不會向例子一樣直白，調用方法在定義處賦值一樣隱含著危險，即使要包含子類類型的static域，也應該通過static方法進行賦值，因為JVM可以保證在static方法調用前完成所有的初始化動作（當然這種保證也是你不應該包含static B b = new B();這樣的初始化行為）；

2. 一個執行個體化的例子：
首先需要知道對象建立的過程：
（1）遇到new指令，檢查類是否完成了載入，驗證，準備，解析，初始化（解析過程就是符號引用解析成直接引用，比如方法名就是一個符號引用，可以在初始化完成後使用這個符號引用的時候進行，正是為了支援動態綁定），沒有完成先進行這些過程；
（2）分配記憶體，採用空閑列表或者指標碰撞的方法，並將新分配的記憶體“置零”，因此所有的執行個體變數在此環節都進行了一次預設初始化為0（引用為null）的過程；
（3）執行<init>方法，包括檢查調用父類的<init>方法（構造器），執行個體變數定義出的賦值動作，執行個體化器順序執行，最後調用構造器中的動作。

這個例子可能更為大家所熟知，也就是它違反了“不要在構造器，clone方法和readObject方法中調用可被覆蓋的方法”。其原因就在於Java中的多態，也就是動態綁定。
父類A的構造器中包含一個protected方法，類B是其子類。

public class WrongInstantiation {   private static class A {     public A() {       doSomething();     }      protected void doSomething() {       System.out.println("A's doSomething");     }   }    private static class B extends A {     private int bInt = 9;      @Override     protected void doSomething() {       System.out.println("B's doSomething, bInt: " + bInt);     }   }    public static void main(String[] args) {     B b = new B();   } } 

輸出結果：

/**    * B's doSomething, bInt: 0    */ 

分析：首先需要知道，在沒有顯示提供構造器時Java編譯器會產生預設構造器，並在開始處調用父類的構造器，因此類B的構造器開始會先調用類A的構造器。
類A中調用了protected方法doSomething，從輸出結果中我們看到實際上調用的是子類的方法實現，而此時子類的執行個體化還未開始，因此bInt並沒有如“預期”那樣是9,而是0；
這就是由於動態綁定，doSomething是一個protected方法，因此它是通過invokevirtual指令調用的，該指令根據對象執行個體的類型找到對應的方法實現（這裡就是B的執行個體對象，對應方法就是類B的方法實現）執行，故而有此結果。

結論：正如前面說的“不要在構造器，clone方法和readObject方法中調用可被覆蓋的方法”。

以上就是為大家介紹的Java類初始化和執行個體化中的2個“雷區”，希望對大家的學習有所協助。