Java類加載機制中最重要的就是程序初始化過程，其中包含了靜態資源，非靜態資源，父類子類，構造方法之間的執行順序。這類知識經常會出現在面試題中，如果沒有搞清楚其原理，在復雜的開源設計中可能無法梳理其業務流程，是java程序員進階的阻礙。
首先通過一個例子來分析java代碼的執行順序：
public class CodeBlockForJava extends BaseCodeBlock {
{
System.out.println("這里是子類的普通代碼塊");
}
public CodeBlockForJava() {
System.out.println("這里是子類的構造方法");
}
@Override
public void msg() {
System.out.println("這里是子類的普通方法");
}
public static void msg2() {
System.out.println("這里是子類的靜態方法");
}
static {
System.out.println("這里是子類的靜態代碼塊");
}
public static void main(String[] args) {
BaseCodeBlock bcb = new CodeBlockForJava();
bcb.msg();
}
Other o = new Other();
}
class BaseCodeBlock {
public BaseCodeBlock() {
System.out.println("這里是父類的構造方法");
}
public void msg() {
System.out.println("這里是父類的普通方法");
}
public static void msg2() {
System.out.println("這里是父類的靜態方法");
}
static {
System.out.println("這里是父類的靜態代碼塊");
}
Other2 o2 = new Other2();
{
System.out.println("這里是父類的普通代碼塊");
}
}
class Other {
Other() {
System.out.println("初始化子類的屬性值");
}
}
class Other2 {
Other2() {
System.out.println("初始化父類的屬性值");
}
}
這個例子比較簡單，在運行代碼之前分析一下：帶有static關鍵字的代碼塊應該是最先執行，其次是非static關鍵字的代碼塊以及類的屬性(Fields),最后是構造方法。帶上父子類的關系后，上面的運行結果為：
這里是父類的靜態代碼塊
這里是子類的靜態代碼塊
初始化父類的屬性值
這里是父類的普通代碼塊
這里是父類的構造方法
這里是子類的普通代碼塊
初始化子類的屬性值
這里是子類的構造方法
這里是子類的普通方法
注意的是類的屬性與非靜態代碼塊的執行級別是一樣的，誰先執行取決于書寫的先后順序。
結論1：父類的靜態代碼塊->子類的靜態代碼塊->初始化父類的屬性值/父類的普通代碼塊(自上而下的順序排列)->父類的構造方法->初始化子類的屬性值/子類的普通代碼塊(自上而下的順序排列)->子類的構造方法。
注：構造函數最后執行。
上面的例子只是小試牛刀，接下來再看一個比較復雜的例子：
public class ClassloadSort1 {
public static void main(String[] args) {
Singleton.getInstance();
System.out.println("Singleton value1:" + Singleton.value1);
System.out.println("Singleton value2:" + Singleton.value2);
Singleton2.getInstance2();
System.out.println("Singleton2 value1:" + Singleton2.value1);
System.out.println("Singleton2 value2:" + Singleton2.value2);
}
}
class Singleton {
static {
System.out.println(Singleton.value1 + "\t" + Singleton.value2 + "\t" + Singleton.singleton);
//System.out.println(Singleton.value1 + "\t" + Singleton.value2);
}
private static Singleton singleton = new Singleton();
public static int value1 = 5;
public static int value2 = 3;
private Singleton() {
value1++;
value2++;
}
public static Singleton getInstance() {
return singleton;
}
int count = 10;
{
System.out.println("count = " + count);
}
}
class Singleton2 {
static {
System.out.println(Singleton2.value1 + "\t" + Singleton2.value2 + "\t" + Singleton2.singleton2);
}
public static int value1 = 5;
public static int value2 = 3;
private static Singleton2 singleton2 = new Singleton2();
private String sign;
int count = 20;
{
System.out.println("count = " + count);
}
private Singleton2() {
value1++;
value2++;
}
public static Singleton2 getInstance2() {
return singleton2;
}
}
這個用例相比第一個，知識點更深了一層。如果你用結論1是沒法分析出正確答案的，但這并不代表結論1就是錯誤的。
運行結果：
Singleton value1:5
Singleton value2:3
Singleton2 value1:6
Singleton2 value2:4
Singleton中的value1,value2并沒有受到構造方法中自加操作的影響。然而Singleton2中的代碼也相同，為什么執行出來的效果就不一樣呢？
要想知道原因，必須先搞清楚Java類加載中具體做了些什么。
JAVA類的加載機制
Java類加載分為5個過程,分別為：加載，連接(驗證，準備，解析)，初始化，使用，卸載。
- 加載
加載主要是將.class文件（也可以是zip包）通過二進制字節流讀入到JVM中。 在加載階段，JVM需要完成3件事：
1）通過classloader在classpath中獲取XXX.class文件，將其以二進制流的形式讀入內存。
2）將字節流所代表的靜態存儲結構轉化為方法區的運行時數據結構；
3）在內存中生成一個該類的java.lang.Class對象，作為方法區這個類的各種數據的訪問入口。
2.1. 驗證
主要確保加載進來的字節流符合JVM規范。驗證階段會完成以下4個階段的檢驗動作：
1）文件格式驗證
2）元數據驗證(是否符合Java語言規范)
3）字節碼驗證（確定程序語義合法，符合邏輯）
4）符號引用驗證（確保下一步的解析能正常執行）
2.2. 準備
準備是連接階段的第二步，主要為靜態變量在方法區分配內存，并設置默認初始值。
2.3. 解析
解析是連接階段的第三步，是虛擬機將常量池內的符號引用替換為直接引用的過程。
初始化
初始化階段是類加載過程的最后一步，主要是根據程序中的賦值語句主動為類變量賦值。
當有繼承關系時，先初始化父類再初始化子類，所以創建一個子類時其實內存中存在兩個對象實例。
注：如果類的繼承關系過長，單從類初始化角度考慮，這種設計不太可取。原因我想你已經猜到了。
通常建議的類繼承關系最多不超過三層，即父-子-孫。某些特殊的應用場景中可能會加到4層，但就此打住，第4層已經有代碼設計上的弊端了。使用
程序之間的相互調用。卸載
即銷毀一個對象，一般情況下中有JVM垃圾回收器完成。代碼層面的銷毀只是將引用置為null。
通過上面的整體介紹后，再來看Singleton2.getInstance()的執行分析：
1）類的加載。運行Singleton2.getInstance(),JVM在首次并沒有發現Singleton類的相關信息。所以通過classloader將Singleton.class文件加載到內存中。
2）類的驗證。略
3）類的準備。將Singleton2中的靜態資源轉化到方法區。value1，value2，singleton在方法區被聲明分別初始為0，0，null。
4）類的解析。略(將常量池內的符號引用替換為直接引用的過程)
5）類的初始化。執行靜態屬性的賦值操作。按照順序先是value1 = 5，value2 = 3,接下來是private static Singleton2 singleton2 = new Singleton2();
這是個創建對象操作，根據 結論1 在執行Singleton2的構造方法之前，先去執行static資源和非static資源。但由于value1,value2已經被初始化過，所以接下來執行的是非static的資源，最后是Singleton2的構造方法：value1++;value2++。
所以Singleton2結果是6和4。
以上除了搞清楚執行順序外，還有一個重點->結論2：靜態資源在類的初始化中只會執行一次。不要與第3個步驟混淆。
有了以上的這個結論，再來看Singleton.getInstance()的執行分析：
1）類的加載。將Singleton類加載到內存中。
2）類的驗證。略
3）類的準備。將Singleton2的靜態資源轉化到方法區。
4）類的解析。略(將常量池內的符號引用替換為直接引用的過程)
5）類的初始化。執行靜態屬性的賦值操作。按照順序先是private static Singleton singleton = new Singleton()，根據 結論1 和結論2，value1和value2不會在此層執行賦值操作。所以singleton對象中的value1,value2只是在0的基礎上進行了++操作。此時singleton對象中的value1=1,value2=1。
然后， public static int value1 = 5; public static int value2 = 3; 這兩行代碼才是真的執行了賦值操作。所以最后的結果：5和3。
如果執行的是public static int value1; public static int value2;結果又會是多少？結果: 1和1。
注：為什么 Singleton singleton = new Singleton()不會對value1,value2進行賦值操作？因為static變量的賦值在類的初始化中只會做一次。
程序在執行private static Singleton singleton = new Singleton()時，已經是對Singleton類的static變量進行賦值操作了。這里new Singleton()是一個特殊的賦值，類似于遞歸里層，外層已經是賦值操作了，所以里層會自動過濾static變量的賦值操作。但非static的變量依然會被賦值。
結論3：在結論2的基礎上，非靜態資源會隨對象的創建而執行初始化。每創建一個對象，執行一次初始化。
掌握結論1，2，3基本對java類中程序執行的順序了如指掌。這還不夠，ClassLoader還沒有介紹呢。
類加載器
JVM提供了以下3種系統的類加載器:
- 啟動類加載器（Bootstrap ClassLoader）：最頂層的類加載器，負責加載 JAVA_HOME\lib 目錄中的，或通過-Xbootclasspath參數指定路徑中的，且被虛擬機認可（按文件名識別，如rt.jar）的類。
- 擴展類加載器（Extension ClassLoader）：負責加載 JAVA_HOME\lib\ext 目錄中的，或通過java.ext.dirs系統變量指定路徑中的類庫。
- 應用程序類加載器（Application ClassLoader）：也叫做系統類加載器，可以通過getSystemClassLoader()獲取，負責加載用戶路徑（classpath）上的類庫。如果沒有自定義類加載器，一般這個就是默認的類加載器。
這3種類加載器先了解一下是什么即可，由于篇幅和主題限制，類加載器將會在下篇文件詳細介紹。
