Java虛擬機如何把編譯好的.class文件加載到虛擬機裏面？加載之後如何初始化類？靜態類變量和實例類變量的初始化過程是否相同，分別是如何初始化的呢？這篇文章就是解決上面3個問題的。
本文前面理論部分比較枯燥，但是如果耐心讀完，結合後面的實例，我相信你以後絕對不會再遇到java類初始化這樣的疑惑。若有不正之處，請多多諒解並歡迎各位能夠給予批評指正，提前謝謝各位。
1. Java虛擬機加載.class過程
虛擬機把Class文件加載到內存，然後進行校驗，解析和初始化，最終形成java類型，這就是虛擬機的類加載機制。加載，驗證，準備，初始化這5個階段的順序是確定的，類的加載過程，必須按照這種順序開始。這些階段通常是相互交叉和混合進行的。解析階段在某些情況下，可以在初始化階段之後再開始—爲了支持java語言的運行時綁定。Java虛擬機規範中，沒有強制約束什麼時候要開始加載，但是，卻嚴格規定了幾種情況必須進行初始化（加載，驗證，準備則需要在初始化之前開始）：
1）遇到 new、getstatic、putstatic、或者invokestatic 這4條字節碼指令，如果沒有類沒有進行過初始化，則出發初始化
2）使用java.lang.reflect包的方法，對壘進行反射調用的時候，如果沒有初始化，則先觸發初始化
3）初始化一個類時候，如果發現父類沒有初始化，則先觸發父類的初始化
在《java編程思想》中對這段也有描述，只不過沒有這麼詳細的描述，它描述的角度是我們平時應用的角度。
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;
}當用new Dog() 創建對象的時候，首先在堆上爲Dog對象分配足夠的空間。
這塊存儲空間會被清零，這就是自動將Dog對象中的所有基本類型的數據都設置成了默認值，而引用類型則被設置成了null（類似靜態類的準備階段的過程）
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類初始化的過程，纔有了這篇博客。廢話不多說，這個例子裏面，有一個地方比較繞：父類在執行構造函數的時候，調用了子類（導出類）重載過的方法，在子類的重載方法中，給實例變量做了一次賦值，正是這次賦值，干擾了我們對類初始化的理解。
我們不管類裏面是怎麼做的，還按照我們上個例子中那樣進行分析：
執行Derived 類 static main 方法的時候，執行類變量初始化，但是此例中父類和子類都沒有類變量，所以此步驟什麼都不做，進行實例變量初始化
執行new Derived()的時候，先調用了父類的構造函數，因爲子類的重載，調用了子類的preProcess方法，爲實例變量whenAmISet 賦值爲”set in preProcess”
然後執行子類Derived 的構造函數，在構造函數中，有編譯器爲我們收集生成的實例變量賦值語句，最終，又將實例變量whenAmISet 賦值爲”set when declared”
所以最終的輸出是： 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://my.oschina.net/kalo/blog/323078