深入 Java 初始化

關於Java 初始化，有多文章都用了很大篇幅的介紹。經典的<<Thinking in java>>更是用了專門的
一章來介紹Java初始化。但在大量有代碼執行個體後面，感覺上仍然沒有真正深入到初始化的本質。

本文以作者對JVM的理解和自己的經驗，對Java的初始化做一個比深入的說明，由於作者有水平限制，
以及JDK各實現版本的變化，可能仍然有不少錯誤和缺點。歡迎行家高手賜教。

要深入瞭解Java初始化，我們無法知道從程式流程上知道JVM是按什麼順序來執行的。瞭解JVM的執行
機制和堆疊追蹤是有效手段。可惜的是，到目前為止。JDK1。4和JDK1。5在javap功能上卻仍然存在
著BUG。所以有些過程我無法用實際的結果向你證明兩種相反的情況

<<Thinking in java>>(第三版)在第四章一開始的時候,這樣來描述Java的初始化工作:
以下譯文原文:
可以這樣認為,每個類都有一個名為Initialize()的方法,這個名字就暗示了它得在使用之前調用,不幸
的是,這麼做的話,使用者就得記住要調用這個方法,java類庫的設計者們可以通過一種被稱為建構函式的
特殊方法,來保證每個對象都能得到被始化.如果類有建構函式,那麼java就會在對象剛剛建立,使用者還來
不及得到的時候,自動調用那個建構函式,這樣初始化就有保障了。

我不知道原作者的描述和譯者的理解之間有多大的差異,結合全章,我沒有發現兩個最關鍵的字"<clinit>"
和"<init>"。至少說明原作者和譯者並沒有真正說明JVM在初始化時做了什麼,或者說並不瞭解JVM的初始化
內幕,要不然明明有這兩個方法,卻為什麼要認為有一個事實上並不存在的"Initialize()"方法呢?

"<clinit>"和"<init>"方法在哪裡？
這兩個方法是實際存在而你又找不到的方法，也許正是這樣才使得一些大師都犯暈。加上jdk實現上的一
些BUG，如果沒有深入瞭解，真的讓人摸不著北。

現在科學體系有一個奇怪的現象，那麼龐大的體系最初都是建立在一個假設的基礎是，假設1是正確的，
由此推匯出2，再繼續推匯出10000000000。可惜的是太多的人根本不在乎2-100000000000這樣的體系都
是建立在假設1是正確的基礎上的。我並不會用“可以這樣認為”這樣的假設，我要確實證明"<clinit>"
和"<init>"方法是真真實實的存在的：

 package debug;
 public class MyTest{
  static int i = 100/0;
  public static void main(String[] args){
   Ssytem.out.println("Hello,World!");
  }
 }

執行一下看看,這是jdk1.5的輸出：

java.lang.ExceptionInInitializerError
Caused by: java.lang.ArithmeticException: / by zero
 at debug.MyTest.<clinit>(Test.java:3)
Exception in thread "main"

請注意，和其它方法調用時產生的異常一樣，異常被定位於debug.MyTest的<clinit>.

再來看：

package debug;
public class Test {
  Test(){
      int i = 100 / 0;
  }
  public static void main(String[] args) {
    new Test();
  }
}

jdk1.5輸入：
Exception in thread "main" java.lang.ArithmeticException: / by zero
 at debug.Test.<init>(Test.java:4)
 at debug.Test.main(Test.java:7)

JVM並沒有把異常定位在Test()構造方法中，而是在debug.Test.<init>。

當我們看到了這兩個方法以後，我們再來詳細討論這兩個“內建初始化方法”（我並不喜歡生造一些
非標準的術語，但我確實不知道如何規範地稱呼他們）。

內建初始化方法是JVM在內部專門用於初始化的特有方法，而不是提供給程式員調用的方法，事實上
“<>”這樣的文法在來源程式中你連編譯都無法通過。這就說明，初始化是由JVM控制而不是讓程式員
來控制的。

類初始化方法：<clinit>
我沒有從任何地方瞭解到<clinit>的cl是不是class的簡寫，但這個方法確實是用來對“類”進行初
始化的。換句話說它是用來初始化static內容相關的。

在類裝載（load）時，JVM會調用內建的<clinit>方法對類成員和靜態初始化塊進行初始化調用。它們
的順序按照源檔案的原文順序。
我們稍微增加兩行static語句：
package debug;
public class Test {
  static int x = 0;
  static String s = "123";
  static {
    String s1 = "456";
    if(1==1)
    throw new RuntimeException();
  }
  public static void main(String[] args) {
    new Test();
  }
}
然後進行反編譯：
javap -c debug.Test

Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
static int x;

static java.lang.String s;

public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   new     #2; //class debug/Test
   3:   dup
   4:   invokespecial   #3; //Method "<init>":()V
   7:   pop
   8:   return

static {};
  Code:
   0:   iconst_0
   1:   putstatic       #4; //Field x:I
   4:   ldc     #5; //String 123
   6:   putstatic       #6; //Field s:Ljava/lang/String;
   9:   ldc     #7; //String 456
   11:  astore_0
   12:  new     #8; //class java/lang/RuntimeException
   15:  dup
   16:  invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   19:  athrow

}
我們可以看到,類初始化正是按照源檔案中定義的原文順序進行。先是聲明

static int x;

static java.lang.String s;

然後對int x和String s進行賦值：
   0:   iconst_0
   1:   putstatic       #4; //Field x:I
   4:   ldc     #5; //String 123
   6:   putstatic       #6; //Field s:Ljava/lang/String;
執行初始化塊的String s1 = "456";產生一個RuntimeException拋
   9:   ldc     #7; //String 456
   11:  astore_0
   12:  new     #8; //class java/lang/RuntimeException
   15:  dup
   16:  invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   19:  athrow

要明白的是，"<clinit>"方法不僅是類初始化方法，而且也是介面初始化方法。並不是所以介面
的屬性都是內聯的，只有直接賦常量值的介面常量才會內聯。而

[public static final] double d = Math.random()*100;

這樣的運算式是需要計算的，在介面中就要由"<clinit>"方法來初始化。

 

下面我們再來看看執行個體初始化方法"<init>"

"<init>"用於對象建立時對對象進行初始化，當在HEAP中建立對象時，一旦在HEAP分配了空間。最
先就會調用"<init>"方法。這個方法包括執行個體變數的賦值（聲明不在其中）和初始化塊，以及構造
方法調用。如果有多個重載的構造方法，每個構造方法都會有一個對應的"<init>"方法。構造方法
隱式或顯示調用父類的構造方法前,總是先執行執行個體變數初始化和初始化塊.同樣，執行個體變數和初始
化塊的順序也是按源檔案的原文順序執行，構造方法中的代碼在最後執行：

package debug;
public class Test {
  int x = 0;
  String s = "123";
  {
    String s1 = "456";
    //if(1==1)
    //throw new RuntimeException();
  }

  public Test(){
    String ss = "789";
  }

  public static void main(String[] args) {
    new Test();
  }
}

javap -c debug.Test的結果：

Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
int x;

java.lang.String s;

public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   iconst_0
   6:   putfield        #2; //Field x:I
   9:   aload_0
   10:  ldc     #3; //String 123
   12:  putfield        #4; //Field s:Ljava/lang/String;
   15:  ldc     #5; //String 456
   17:  astore_1
   18:  ldc     #6; //String 789
   20:  astore_1
   21:  return

public static void main(java.lang.String[]);
  Code:
   0:   new     #7; //class debug/Test
   3:   dup
   4:   invokespecial   #8; //Method "<init>":()V
   7:   pop
   8:   return
}

如果在同一個類中，一個構造方法調用了另一個構造方法，那麼對應的"<init>"方法就會調用另一
個"<init>"，但是執行個體變數和初始化塊會被忽略，否則它們就會被多次執行。

package debug;
public class Test {
  String s1 = rt("s1");
  String s2 = "s2";
 
  public Test(){
    s1 = "s1";
  }
  public Test(String s){
    this();
    if(1==1) throw new Runtime();
  }
  String rt(String s){
    return s;
  }
  public static void main(String[] args) {
    new Test("");
  }
}

反編譯的結果：
Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;

java.lang.String s2;

public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  aload_0
   21:  ldc     #2; //String s1
   23:  putfield        #4; //Field s1:Ljava/lang/String;
   26:  return

public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #7; //Method "<init>":()V
   4:   new     #8; //class java/lang/RuntimeException
   7:   dup
   8:   invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   11:  athrow

java.lang.String rt(java.lang.String);
  Code:
   0:   aload_1
   1:   areturn

public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class debug/Test
   3:   dup
   4:   ldc     #11; //String
   6:   invokespecial   #12; //Method "<init>":(Ljava/lang/String;)V
   9:   pop
   10:  return

}

我們看到，由於Test(String s)調用了Test();所以"<init>":(Ljava/lang/String;)V不再對
執行個體變數和初始化塊進次初始化：

public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #7; //Method "<init>":()V
   4:   new     #8; //class java/lang/RuntimeException
   7:   dup
   8:   invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   11:  athrow

而如果兩個構造方法是相互獨立的，則每個構造方法調用前都會執行執行個體變數和初始化塊的調用：

package debug;
public class Test {
  String s1 = rt("s1");
  String s2 = "s2";
  {
    String s3 = "s3";
  }
  public Test() {
    s1 = "s1";
  }

  public Test(String s) {
    if (1 == 1)
      throw new RuntimeException();
  }

  String rt(String s) {
    return s;
  }

  public static void main(String[] args) {
    new Test("");
  }
}

反編譯的結果：

Compiled from "Test.java"
public class debug.Test extends java.lang.Object{
java.lang.String s1;

java.lang.String s2;

public debug.Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  ldc     #7; //String s3
   22:  astore_1
   23:  aload_0
   24:  ldc     #2; //String s1
   26:  putfield        #4; //Field s1:Ljava/lang/String;
   29:  return

public debug.Test(java.lang.String);
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   aload_0
   6:   ldc     #2; //String s1
   8:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;
   11:  putfield        #4; //Field s1:Ljava/lang/String;
   14:  aload_0
   15:  ldc     #5; //String s2
   17:  putfield        #6; //Field s2:Ljava/lang/String;
   20:  ldc     #7; //String s3
   22:  astore_2
   23:  new     #8; //class java/lang/RuntimeException
   26:  dup
   27:  invokespecial   #9; //Method java/lang/RuntimeException."<init>":()V
   30:  athrow

java.lang.String rt(java.lang.String);
  Code:
   0:   aload_1
   1:   areturn

public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class debug/Test
   3:   dup
   4:   ldc     #11; //String
   6:   invokespecial   #12; //Method "<init>":(Ljava/lang/String;)V
   9:   pop
   10:  return

}

明白了上面這些知識,我們來做一個小測試吧:
public class Test2 extends Test1{
 {
  System.out.print("1");
 }
 Test2(){
  System.out.print("2");
 }
 static{
  System.out.print("3");
 }
 {
  System.out.print("4");
 }
 public static void main(String[] args) {
  new Test2();
 }
}
class Test1 {
 Test1(){
  System.out.print("5"); 
 }
 static{
  System.out.print("6");
 }
}
試試看能清楚列印的順序嗎?如果沒有new Test2()將列印什麼?