深入理解Java初始化的含義

轉自：http://www.linuxdiyf.com/viewarticle.php?id=18987

 

　　可以這樣認為，每個類都有一個名為Initialize()的方法，這個名字就暗示了它得在使用之前調用，不幸的是，這麼做的話，使用者就得記住要調用這個方法，java類庫的設計者們可以通過一種被稱為建構函式的特殊方法，來保證每個對象都能得到被始化.如果類有建構函式，那麼java就會在對象剛剛建立，使用者還來不及得到的時候，自動調用那個建構函式，這樣初始化就有保障了。

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

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

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

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

　　執行一下看看，這是jdk1.5的輸出:

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

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

　　再來看:

CODE: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.(Test.java:4) 　　at debug.Test.main(Test.java:7)

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

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

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

 

　　類初始化方法:

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

　　在類裝載(load)時，JVM會調用內建的方法對類成員和靜態初始化塊進行初始化調用。它們的順序按照源檔案的原文順序。

　　我們稍微增加兩行static語句:

CODE: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(); 　} }

　　然後進行反編譯:

CODE: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."":()V 　　4: return 　　public static void main(java.lang.String[]); 　　Code: 　　0: new #2; //class debug/Test 　　3: dup 　　4: invokespecial #3; //Method "":()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."":()V 　　19: athrow 　}

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

CODE:static int x; static java.lang.String s;

　　然後對int x和String s進行賦值:

CODE: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拋

CODE:9: ldc #7; //String 456 11: astore_0 12: new #8; //class java/lang/RuntimeException 15: dup 16: invokespecial #9; //Method java/lang/RuntimeException."":()V 19: athrow

　　要明白的是，""方法不僅是類初始化方法，而且也是介面初始化方法。並不是所以介面

　　的屬性都是內聯的，只有直接賦常量值的介面常量才會內聯。而

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

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

 

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

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

CODE: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."":()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 "":()V 　　7: pop 　　8: return 　}

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

CODE: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(""); } }

　　反編譯的結果:

CODE: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."":()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 "":()V 　　4: new #8; //class java/lang/RuntimeException 　　7: dup 　　8: invokespecial #9; //Method java/lang/RuntimeException."":()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 "":(Ljava/lang/String;)V 　　9: pop 　　10: return 　}

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

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

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

CODE: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(""); } }

　　反編譯的結果:

CODE: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."":()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."":()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."":()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 "":(Ljava/lang/String;)V 　　9: pop 　　10: return 　}

　　明白了上面這些知識，我們來做一個小測試吧:

CODE: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()將列印什嗎？