Java虛擬機如何把編譯好的.class文件加載到虛擬機里面？加載之后如何初始化類？靜態類變量和實例類變量的初始化過程是否相同，分別是如何初始化的呢？這篇文章就
是解決上面3個問題的。
若有不正之處，請多多諒解並歡迎各位能夠給予批評指正，提前謝謝各位了。
1. Java虛擬機加載.class過程
虛擬機把Class文件加載到內存，然后進行校驗，解析和初始化，最終形成java類型，這就是虛擬機的類加載機制。加載，驗證，准備，初始化這5個階段的順序是確定的，
類的加載過程，必須按照這種順序開始。這些階段通常是相互交叉和混合進行的。解析階段在某些情況下，可以在初始化階段之后再開始---為了支持java語言的運行時綁定。
Java虛擬機規范中，沒有強制約束什么時候要開始加載，但是，卻嚴格規定了幾種情況必須進行初始化（加載，驗證，准備則需要在初始化之前開始）：
1）遇到 new、getstatic、putstatic、或者invokestatic 這4條字節碼指令，如果沒有類沒有進行過初始化，則觸發初始化
2）使用java.lang.reflect包的方法，對壘進行反射調用的時候，如果沒有初始化，則先觸發初始化
3）初始化一個類時候，如果發現父類沒有初始化，則先觸發父類的初始化
2. 加載，驗證，解析
加載就是通過指定的類全限定名，獲取此類的二進制字節流，然后將此二進制字節流轉化為方法區的數據結構，在內存中生成一個代表這個類的Class對象。驗證是為了確
保Class文件中的字節流符合虛擬機的要求，並且不會危害虛擬機的安全。加載和驗證階段比較容易理解，這里就不再過多的解釋。解析階段比較特殊，解析階段是虛擬機
將常量池中的符號引用轉換為直接引用的過程。如果想明白解析的過程，得先了解一點class文件的一些信息。class文件采用一種類似C語言的結構體的偽結構來存儲我們編
碼的java類的各種信息。其中，class文件中常量池（constant_pool）是一個類似表格的倉庫，里面存儲了我們編寫的java類的類和接口的全限定名，字段的名稱和描述符，
方法的名稱和描述符。在java虛擬機將class文件加載到虛擬機內存之后，class類文件中的常量池信息以及其他的數據會被保存到java虛擬機內存的方法區。我們知道class文件
的常量池存放的是java類的全名，接口的全名和字段名稱描述符，方法的名稱和描述符等信息，這些數據加載到jvm內存的方法區之后，被稱做是符號引用。而把這些類的
全限定名，方法描述符等轉化為jvm可以直接獲取的jvm內存地址，指針等的過程，就是解析。虛擬機實現可以對第一次的解析結果進行緩存，避免解析動作的重復執行。
在解析類的全限定名的時候，假設當前所處的類為D，如果要把一個從未解析過的符號引用N解析為一個類或者接口C的直接引用，具體的執行辦法就是虛擬機會把代表N的
全限定名傳遞給D的類加載器去加載這個類C。這塊可能不太好理解，但是我們可以直接理解為調用D類的ClassLoader來加載N，然后就完成了N--->C的解析，就可以了。
3. 准備階段
之所以把在解析階段前面的准備階段，拿到解析階段之后講，是因為，准備階段已經涉及到了類數據的初始化賦值。和我們本文講的初始化有關系，所以，就拿到這里來講
述。在java虛擬機加載class文件並且驗證完畢之后，就會正式給類變量分配內存並設置類變量的初始值。這些變量所使用的內存都將在方法區分配。注意這里說的是類變量，
也就是static修飾符修飾的變量，在此時已經開始做內存分配，同時也設置了初始值。比如在 Public static int value = 123 這句話中，在執行准備階段的時候，會給value
分配內存並設置初始值0， 而不是我們想象中的123. 那么什么時候 才會將我們寫的123 賦值給 value呢？就是我們下面要講的初始化階段。
4. 初始化階段
類初始化階段是類加載過程的最后階段。在這個階段，java虛擬機才真正開始執行類定義中的java程序代碼。Java虛擬機是怎么完成初始化的呢？這要從編譯開始講起。在編
譯的時候，編譯器會自動收集類中的所有靜態變量（類變量）和靜態語句塊（static｛｝塊）中的語句合並產生的，編譯器收集的順序是根據語句在java代碼中的順序決定的。
收集完成之后，會編譯成java類的 static{} 方法，java虛擬機則會保證一個類的static{} 方法在多線程或者單線程環境中正確的執行，並且只執行一次。在執行的過程中，便完
成了類變量的初始化。值得說明的是，如果我們的java類中，沒有顯式聲明static{}塊，如果類中有靜態變量，編譯器會默認給我們生成一個static{}方法。 我們可以通過
javap -c 的命令，來看一下java字節碼中編譯器為我們生成或者合並的static{} 方法：
public class StaticValInitTest { public static int value = 123; }
上面我們講述的是單類的情況，如果出現繼承呢？如果有繼承的話，父類中的類變量該如何初始化？這點由虛擬機來解決：虛擬機會保證在子類的static{}方法執行之
前，父類的static{}方法已經執行完畢。由於父類的static{}方法先執行，也就意味着父類的靜態變量要優先於子類的靜態變量賦值操作。
上面講的都是靜態變量，實例變量怎么解決呢？實例變量的初始化，其實是和靜態變量的過程是類似的，但是時間和地點都不同哦。我們以下面的Dog類為例來講一講。
public class Dog { public String type = "tai di"; public int age = 3; }
1）當用new Dog() 創建對象的時候，首先在堆上為Dog對象分配足夠的空間。
2）這塊存儲空間會被清零，這就是自動將Dog對象中的所有基本類型的數據都設置成了默認值，而引用類型則被設置成了null（類似靜態類的准備階段的過程）
3）Java收集我們的實例變量賦值語句，合並后在構造函數中執行賦值語句。沒有構造函數的，系統會默認給我們生成構造函數。
至此，java類初始化的理論基礎已經完成了，其中的大部分的理論和思想都出自《深入理解java虛擬機》這本書。有了以上的理論基礎，
再復雜的類初始化的情況，我們都可以應對了，下面就拿一個例子做一個具體的分析吧
public class Insect { private int i = 9; protected int j; protected static int x1 = printInit("static Insect.x1 initialized"); Insect() { System.out.println("基類構造函數階段： i = " + i + ", j = " + j); j = 39; } static int printInit(String s) { System.out.println(s); return 47; } } public class Beetle extends Insect { protected int k = printInit("Beetle.k initialized"); protected static int x2 = printInit("static Beetle.x2 initialized"); public static void main(String[] args) { Beetle b = new Beetle(); } }
上面例子來自《java編程思想》，以上代碼的執行結果是什么呢？如果對上面我們講的理論理解的話，很容易就知道結果是：
static Insect.x1 initialized
static Beetle.x2 initialized
基類構造函數階段： i = 9, j = 0
Beetle.k initialized
具體的執行結果過程是：
在執行Beetle 類的 main方法的時候，因為該main方法是static方法，我們在上面已經知道，在執行類的static方法的時候，如果該類沒有初始化，則要進行初始化，
因此，我們在執行main方法的時候，會執行加載--驗證--准備--解析---初始化這個過程。在進行最后的初始化的時候，又有一個約束：虛擬機會保證在子類的static{}
方法執行之前，父類的static{}方法已經執行完畢。所以，在執行完解析之后，會先執行父類的初始化，在執行父類初始化的時候，
輸出: static Insect.x1 initialized
然后接着初始化子類，輸出：static Beetle.x2 initialized
以上兩行輸出，是靜態變量的初始化，是在第一次調用靜態方法，即，在執行new、getstatic、putstatic、或者invokestatic 這4條字節碼指令時候觸發的。所以，
你如果把上例中的static main 方法中的 Beetle b = new Beetle();
注釋掉，上面兩行仍然會輸出出來。然后就是執行Beetle b = new Beetle();這句代碼了。我們知道，在實例化子類對象的時候，會自動調用父類的構造函數。
所以，接着就輸出：基類構造函數階段： i = 9, j = 0
緊接着是執行自己的構造函數，在堆上創建類實例對象，實例對象空間清零，然后執行賦值語句k = printInit("Beetle.k initialized");
輸出： Beetle.k initialized
至此，整個類加載並初始化完畢，是不是理解起來就很簡單了，趁勝追擊，我們還是再來看一個例子吧：
public class Base { Base() { preProcess(); } void preProcess() { } } public class Derived extends Base { public String whenAmISet = "set when declared"; @Override void preProcess() { whenAmISet = "set in preProcess"; } public static void main(String[] args) { Derived d = new Derived(); System.out.println(d.whenAmISet); } }
這個例子來源與@左耳朵耗子的博客，我就是看了他博客中的這個例子，才想起來寫篇文章里理順下java類初始化的過程，才有了這篇博客。廢話不多說，這個例子里面，有
一個地方比較繞：父類在執行構造函數的時候，調用了子類（導出類）重載過的方法，在子類的重載方法中，給實例變量做了一次賦值，正是這次賦值，干擾了我們對類初始
化的理解。
我們不管類里面是怎么做的，還按照我們上個例子中那樣進行分析：
1. 執行Derived 類 static main 方法的時候，執行類變量初始化，但是此例中父類和子類都沒有類變量，所以此步驟什么都不做，進行實例變量初始化
2. 執行new Derived()的時候，先調用了父類的構造函數，因為子類的重載，調用了子類的preProcess方法，為實例變量whenAmISet 賦值為"set in preProcess"
3. 然后執行子類Derived 的構造函數，在構造函數中，有編譯器為我們收集生成的實例變量賦值語句，最終，又將實例變量whenAmISet 賦值為"set when declared"
4. 所以最終的輸出是： set when declared
如果對這個還不太理解的話，可以再Derived 類里面添加注釋，改成下面的樣子，輸出看看，是不是對這個執行過程更清晰了呢？
public class Derived extends Base { // 准備階段賦值 whenAmISet=null public String whenAmISet = "set when declared"; public Derived() { System.out.println("do son constructor"); } @Override void preProcess() { System.out.println("do son process"); System.out.println("whenAmISet:" + whenAmISet); whenAmISet = "set in preProcess"; System.out.println("whenAmISet:" + whenAmISet); System.out.println("set in preProcess end"); } public static void main(String[] args) { Derived d = new Derived(); System.out.println(d.whenAmISet); } }
參考資料：
《深入理解java虛擬機》
《Java編程思想》
http://coolshell.cn/articles/1106.html
看博客的時候沒覺得什么，寫博客的時候才知道還要組織語言，還要排版神馬的，所以還希望轉載的時候能給個
http://www.cnblogs.com/jimxz/p/3974939.html
鏈接說明，謝謝