Java程式執行時，第一件事情就是試圖訪問main方法，因為main相等於程式的入口，如果沒有main方法，程式將無法啟動，main方法更是佔一個獨立的執行緒。

下面是一段程式碼 幫助我們分析

class A {
    public A() {
        System.out.println("A的構造方法");
    }

    public static int j = print();

    public static int print() {
        System.out.println("A print");
        return 521;
    }
}

public class Test1 extends A {
    public Test1() {
        System.out.println("Test1的構造方法");
    }

    public static int k = print();

    public static int print() {
        System.out.println("Test print");
        return 522;
    }

    public static void main(String[] args) {
        System.out.println("main start");
        Test1 t1 = new Test1();
    }
}
 

A print
Test print
main start
A的構造方法
Test1的構造方法

因為靜態部分是依賴於類，而不是依賴於物件存在的，所以靜態部分的載入優先於物件存在。

　　當找到main方法後，因為main方法雖然是一個特殊的靜態方法，但是還是靜態方法，此時JVM會載入main方法所在的類，試圖找到類中其他靜態部分，即首先會找main方法所在的類。

執行順序大致分類：

　　1.靜態屬性，靜態方法宣告，靜態塊。

　　2.動態屬性，普通方法宣告，構造塊。

　　3.構造方法。

1.1 靜態：

　　當載入一個類時，JVM會根據屬性的資料型別第一時間賦預設值（一舉生成的）。然後再進行靜態屬性初始化，併為靜態屬性分配記憶體空間，靜態方法的宣告，靜態塊的載入，沒有優先順序之分，按出現順序執行，靜態部分僅僅載入一次。至此為止，必要的類都已經載入完畢，物件就可以被建立了。

1.2 普通：

　　當new一個物件時，此時會呼叫構造方法，但是在呼叫構造方法之前，（此刻1.1已經完成，除非被打斷而暫停）執行動態屬性定義並設定預設值（一舉生成的）。然後動態屬性初始化，分配記憶體，構造塊，普通方法宣告（只是載入，它不需要初始化，只有呼叫它時才分配記憶體，當方法執行完畢後記憶體立即釋放），沒有優先順序之分，按出現順序執行。最後進行構造方法中賦值。當再次建立一個物件，不再執行靜態部分，僅僅重複執行普通部分。

　　注意：如果存在繼承關係，建立物件時，依然會首先進行動態屬性進行定義並設預設值，然後父類的構造器才會被呼叫，其他一切都是先父類再子類（因為子類的static初始化可能會依賴於父類成員能否被正確初始化），如果父類還有父類，依次類推，不管你是否打算產生一個該父類的物件，這都是自然發生的。

下面是一道阿里巴巴的面試題：非常經典，可以不斷的改變程式的順序，來找到執行順序機制。

　　程式碼部分：

public class Text {
    public static int k = 0;
    public static Text t1 = new Text("t1");
    public static Text t2 = new Text("t2");
    public static int i = print("i");
    public static int n = 99;
    public int j = print("j");

    {
        print("構造塊");
    }
    static {
        print("靜態塊");
    }

    public Text(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;
    }

    public static int print(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }

    public static void main(String args[]) {
        Text t = new Text("init");
    }
}

 　　執行結果：

1:j   i=0    n=0
2:構造塊   i=1    n=1
3:t1   i=2    n=2
4:j   i=3    n=3
5:構造塊   i=4    n=4
6:t2   i=5    n=5
7:i   i=6    n=6
8:靜態塊   i=7    n=99
9:j   i=8    n=100
10:構造塊   i=9    n=101
11:init   i=10    n=102

總結：只要按照這個步驟，遇到這一類問題就可以解決了。     

    　　　　  1-3：類載入過程，不涉及構造方法

      　　　　1-5: 例項化過程，涉及構造方法

　　1.類中所有屬性的預設值（一舉而成）

　　2. 父類靜態屬性初始化，靜態塊，靜態方法的宣告（按出現順序執行）

　　3. 子類靜態屬性初始化，靜態塊，靜態方法的宣告 （按出現順序執行）

　　4.  呼叫父類的構造方法，

　　　　　　首先父類的非靜態成員初始化，構造塊，普通方法的宣告（按出現順序執行）

　　　　　　然後父類構造方法

　　5.  呼叫子類的構造方法，

　　　　　　首先子類的非靜態成員初始化，構造塊，普通方法的宣告（按出現順序執行）

　　　　　　然後子類構造方法

　　　（注意：類載入過程中，可能呼叫了例項化過程（因為static可以修飾方法，屬性，程式碼塊，內部類），此時則會暫停類載入過程而先執行例項化過程（被打斷），執行結束再進行類載入過程，上面阿里那道面試題就是典型的暫停類載入。