第二天，哼著小曲來到教室，摘下眼鏡擦眼鏡，準備上課。一擡頭看見了一個大長腿，艾瑪，真好看。

看夠了沒！lsp。

我：啊，看夠了...啊，不是不是（慌忙帶上眼鏡），喲！冉冉大妹紙。

冉冉：誰是你大妹紙啊，往裡坐坐。

我：好勒！

冉冉：我昨天回去看了看一條不會寫作的碼農寫的簡單理解Java的構造器，把建構函式給整明白了，但是問題來了，什麼初始化，還有什麼順序，真讓人頭疼，給我講講？

我：叫哥哥給你講。

冉冉：算了，我找別人吧。

我：今天我要是給你講不明白，我就不放學！

今天要講的重點

• 成員變數預設初值
• 構造器初始化以及初始化順序
• 靜態資料的初始化

一、成員變數預設初值

要知道：只有成員變數，在執行時期才會進行賦予預設的初始值。Java要儘量保證所有變數在使用前都能得到恰當的初始化。而對於方法中含有的區域性變數，Java則不會給預設值，而是以編譯錯誤的形式，來保證區域性變數的初始化；

下面來看看Java給的預設初始值是多少

boolean : false
char    : [ ]
byte    : 0
short   : 0
int     : 0
long    : 0
float   : 0.0
double  : 0.0
reference(參照型別(可以理解為物件)) : null 

冉冉：這個char為一箇中括號是什麼意思？

我：這個啊，char的初始值也預設為0，所以顯示為空白了

這是Java預設給你的初始值，當然如果你在方法中這樣定義，那編譯器肯定有點小脾氣。

冉冉：嗯？你怎麼沒說String呢？

我：你說String是什麼型別的？

冉冉：當然基本資料型別呀（脫口而出）

我：鼻子給你打歪，你家的Java是九種基本資料型別啊，他也是個參照型別啊，不然你以為你怎麼能寫

String str = new String();

這樣的程式碼啊；好了，咱繼續扯；

二、構造器初始化以及初始化順序

• 構造器初始化

我：昨天你看了那什麼什麼碼農的構造器，那我就不再給你囉嗦了，直接說重點吧？

冉冉：完全沒問題！

我：好！廢話不多說，開始，看下邊的程式碼

public class Student {
    private String username;
    private String password;
    
    public Student(String username,String password){
        this.username = username;
        this.password = password;
    }
}

冉冉：哎哎哎！你也看過那篇文章？

我：嘿嘿，那必須啊，他多帥啊，我也關注了，繼續繼續！

這是使用建構函式進行的初始化變數，當你呼叫這個建構函式的時候，傳入的兩個引數，就是初始化的值，測試一下

public class Student {
    private String username;
    private String password;

    Student(String username, String password) {
        this.username = username;
        this.password = password;
    }
    public static void main(String[] args) {
        Student testMain2 = new Student("1","1");
        System.out.println(testMain2.username);
        System.out.println(testMain2.password);
    }
}

又來了一個重點：當你進行初始化的時候，username和password的值首先會被置為null，然後才變成了"1","1"。對於所有基本型別和物件參照，包括在定義時已經設定了初值變數，這種情況都是成立的。

我：理解了這個知識點，那咱們進入下一個，也是你頭疼的地方，初始化的順序。打什麼瞌睡，仔細聽講了！

• 初始化順序

在類的內部，變數定義的先後順序決定了他們的初始化順序，即順序初始化，即使他們分散在各個方法之間，也會在第一時間進行初始化（注意：初始化要優先於方法載入，包括構造方法）

冉冉：有點不理解分散在各個方法之間

我：看程式碼就理解了，把上邊的程式碼做個簡單的改造

public class Student {
    private String username;
    private String password;

    Student(String username, String password) {
        this.username = username;
        this.password = password;
    }
    int i;
    void f(){}
    boolean b;
}

這就叫做分散各個方法之間。這時候的初始化順序，並不會因為建構函式在變數 i 之前，構造方法就先初始化；懂了吧！

冉冉：明白了

那咱們繼續：

public class TestMain {
    public static void main(String[] args) {
        House h = new House();
        h.f();
    }
}
class Window {
    Window(int marker) {
        System.out.println("Window方法的構造器" + marker);
    }
}
class House {
    Window w1 = new Window(1);
    House() {
        System.out.println("House()方法");
        w3 = new Window(33);
    }
    Window w2 = new Window(2);
    void f() {
        System.out.println("f()");
    }
    Window w3 = new Window(3);
}

這段程式碼是怎麼執行的呢，來分析分析吧？

冉冉：好的，我試試看

（幾分鐘後，娓娓道來）首先main方法中 new了個House的物件，然後根據你剛剛說的，先初始化所有的變數，這時候會執行

Window w1 = new Window(1);

Window w2 = new Window(2);

Window w3 = new Window(3);

每次執行，都會去呼叫Window類中的構造方法，輸出一句 "Window方法的構造器" + 所傳的 1 2 3

緊接著在 載入House() 這個構造方法，輸出一個 "House()" 再執行 w3 = new Window(33); 輸出一個"Window方法的構造器33"

最後呼叫了 f() 這個方法，輸出了"f()"；

對不對，對不對。冉冉激動的說到

我：不錯不錯，孺子可教也，看下結果吧！

在整個程式執行的過程中 w3 會被初始化兩次：一次在呼叫構造器前，一次在呼叫期間，而第一次的物件被無情的拋棄了，被當成了垃圾給運送走了。

冉冉：終於弄明白了，你挺厲害的呀！

我：那何止厲害，我還帥呢！別急，還沒結束，還有一個重點呢，咱繼續掰扯！

三、靜態資料的初始化

我：知道什麼是靜態嗎？

冉冉：知道知道，static關鍵字嘛。

我：嗯對，就是這個關鍵字，既然知道，那我就不給你講基礎了吧，直接說重點！

首先呢，你要知道一點：無論你建立多少個物件，靜態資料都只會佔用一份儲存區域。而且static關鍵字不能用於區域性變數。

看下面的例子，瞭解一下初始化順序：

public class TestMain {
    public static void main(String[] args) {
        System.out.println("new 一次Cupboard()");
        new Cupboard();
        System.out.println("new 二次Cupboard()");
        new Cupboard();
        table.f2(1);
        cupboard.f3(1);

    }
    static Table table = new Table();
    static Cupboard cupboard = new Cupboard();

}
class Bowl {
    Bowl(int i) {
        System.out.println("bowl類的構造方法--->" + i);
    }
    void f1(int i) {
        System.out.println("方法f1() ---> " + i);
    }
}
class Table {
    static Bowl bowl1 = new Bowl(1);
    Table() {
        System.out.println("Table類的構造方法");
        bowl2.f1(1);
    }
    void f2(int i) {
        System.out.println("方法f2() ---> " + i);
    }
    static Bowl bowl2 = new Bowl(2);
}
class Cupboard {
    Bowl bowl3 = new Bowl(3);
    static Bowl bowl4 = new Bowl(4);
    Cupboard() {
        System.out.println("Cupboard類的構造方法");
        bowl4.f1(2);
    }
    void f3(int i) {
        System.out.println("方法f3() ---> " + i);
    }
    static Bowl bowl5 = new Bowl(5);
}

這個我給你分析，你聽仔細哦~，不要走神，只講一遍

冉冉：好（打起精神）

首先，主函數作為入口函數，先初始化靜態變數，即執行 static Table table = new Table(); 執行這條語句之後，就會載入Table類，這是一定的，即使不是一個靜態，也會載入這個類，然後再去執行 static Bowl bowl1 = new Bowl(1); 此時就會去載入Bowl類的構造方法，從而輸出了一句 "bowl類的構造方法 ---> 1" ，然後程式繼續載入Table了中的靜態變數：

static Bowl bowl2 = new Bowl(2);  再次呼叫Bowl的構造方法，輸出"bowl類的構造方法 ---> 2",然後才載入Table類的構造方法，輸出"Table類的構造方法",然後執行 bowl2.f1(1); 

程式回到主函數，再執行 static Cupboard cupboard = new Cupboard(); 然後載入Cupboard類，接著載入類中的靜態變數，重複上邊的情況，按順序執行。這裡注意的是，執行完兩個靜態變數，會接著執行非靜態的，即 Bowl bowl3 = new Bowl(3);

執行完static Cupboard cupboard = new Cupboard();程式再次回到主函數，執行第一個輸出語句，緊接著，執行

new Cupboard(); 你說說，下一步該執行什麼了？冉冉同學

冉冉：下一步啊，這還不簡單，先執行靜態變數，執行完，再執行非靜態的，然後再執行構造方法唄，這有啥難的。

我：不對哦~，（挖個坑你就跳，這還不是隨隨便便就把你騙到手了麼，哈哈哈）

重點：被static修飾的變數，本質上，只會在類載入的時候載入一次，所以嘛，直接就會執行 Bowl bowl3 = new Bowl(3);

同樣的，你再次回到主函數，再 new Cupboard(); 也還會是這樣執行的

冉冉：戚，你也就欺負欺負我這種小白了，啥也不是，再見！（說著起身就要走）

我：哎哎哎，別生氣啊，我給你總結一下啊！

冉冉：不用！哼！

四、總結

所以，現在來看，初始化順序就顯而易見了  靜態變數 --> 非靜態變數 --> 構造方法

所有文字，程式碼，均為手敲，如有錯誤，或補充，歡迎指出，一定及時改正！

來都來了，點個關注，點個讚唄！