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

（1）在使用new實例化對象，訪問靜態(tài)數(shù)據(jù)和方法時，也就是遇到指令：new，getstatic/putstatic和invokestatic時；
（2）使用反射對類進行調用時；
（3）當初始化一個類時，父類如果沒有進行初始化，先觸發(fā)父類的初始化；
（4）執(zhí)行入口main方法所在的類；
（5）JDK1.7動態(tài)語言支持中方法句柄所在的類，如果沒有初始化觸發(fā)起初始化；

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

1. 一個類初始化的例子：
這個例子我使用一個外圍類包含2個有繼承關系的靜態(tài)成員類，因為外圍類的初始化和靜態(tài)成員類沒有因果關系，因此這樣展示是安全和方便的；
父類A和子類B分別包含main函數(shù)，由上面的觸發(fā)條件（4）可知，通過分別調用這個兩個main函數(shù)來觸發(fā)不同的類初始化路徑；
這個例子的問題在于父類包含子類的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函數(shù)時輸出結果：

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

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

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

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

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

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

2. 一個實例化的例子：
首先需要知道對象創(chuàng)建的過程：
（1）遇到new指令，檢查類是否完成了加載，驗證，準備，解析，初始化（解析過程就是符號引用解析成直接引用，比如方法名就是一個符號引用，可以在初始化完成后使用這個符號引用的時候進行，正是為了支持動態(tài)綁定），沒有完成先進行這些過程；
（2）分配內存，采用空閑列表或者指針碰撞的方法，并將新分配的內存“置零”，因此所有的實例變量在此環(huán)節(jié)都進行了一次默認初始化為0（引用為null）的過程；
（3）執(zhí)行<init>方法，包括檢查調用父類的<init>方法（構造器），實例變量定義出的賦值動作，實例化器順序執(zhí)行，最后調用構造器中的動作。

這個例子可能更為大家所熟知，也就是它違反了“不要在構造器，clone方法和readObject方法中調用可被覆蓋的方法”。其原因就在于Java中的多態(tài)，也就是動態(tài)綁定。
父類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，從輸出結果中我們看到實際上調用的是子類的方法實現(xiàn)，而此時子類的實例化還未開始，因此bInt并沒有如“預期”那樣是9,而是0；
這就是由于動態(tài)綁定，doSomething是一個protected方法，因此它是通過invokevirtual指令調用的，該指令根據(jù)對象實例的類型找到對應的方法實現(xiàn)（這里就是B的實例對象，對應方法就是類B的方法實現(xiàn)）執(zhí)行，故而有此結果。

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

以上就是為大家介紹的Java類初始化和實例化中的2個“雷區(qū)”，希望對大家的學習有所幫助。

最新評論