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

看夠了沒！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(); 也還會是這樣執行的

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

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

冉冉：不用！哼！

四、總結

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

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

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