java構造器詳解

阿新 • • 發佈：2020-12-22

什麼是構造器
構造器通常也叫構造方法、建構函式，構造器在每個專案中幾乎無處不在。當你new一個物件時，就會呼叫構造器。構造器格式如下：

[修飾符，比如public] 類名 (引數列表，可以沒有引數){
	//這裡不能有return
}

預設構造器
如果沒有定義構造器，則會預設一個無參構造器，這就是為什麼你定義了一個物件，比如 People，沒有定義任何構造器卻可以new這個物件,比如 new People() 。如果自定義了構造器，則會覆蓋預設構造器。
如何禁止物件被外部建立
一些特殊需求，不希望定義的物件被外部建立（典型的就是單例了），那直接將構造器的修飾符改為 private 即可。這樣就不能在外部通過new來建立這個物件了。
構造器過載
與普通方法一樣，構造器也支援過載。一個物件中是可以支援同時定義多個構造器，通過不同的引數列表來實現過載。經常看到程式碼中new一個物件時，有時傳入引數，有時又可以不用傳。比如：new People()跟new People("張三")，這裡就是過載了。
構造器的繼承
子類構造器會預設呼叫父類無參構造器，如果父類沒有無參構造器，則必須在子類構造器的第一行通過 super關鍵字指定呼叫父類的哪個構造器，具體看下文例子。final類是不允許被繼承的，編譯器會報錯。很好理解，由於final修飾符指的是不允許被修改，而繼承中，子類是可以修改父類的，這裡就產生衝突了，所以final類是不允許被繼承的。
構造器、靜態程式碼塊、構造程式碼塊的執行順序，詳見下文例項
- 無繼承的情況下的執行順序
  靜態程式碼塊：只在程式啟動後執行一次，優先順序最高
  構造程式碼塊：任何一個構造器被呼叫的時候，都會先執行構造程式碼塊，優先順序低於靜態程式碼塊
  構造器：優先順序低於構造程式碼塊
  總結一下優先順序：靜態程式碼塊 > 構造程式碼塊 > 構造器
- 有繼承的情況下的執行順序：
  父類靜態程式碼塊：只在程式啟動後執行一次，優先順序最高
  子類靜態程式碼塊：只在程式啟動後執行一次，優先順序低於父類靜態程式碼塊
  父類構造程式碼塊：父類任何一個構造器被呼叫的時候，都會執行一次，優先順序低於子類靜態程式碼塊
  父類構造器：優先順序低於父類構造程式碼
  子類構造程式碼塊
  
  ：子類任何一個構造器被呼叫的時候，都會執行一次，優先順序低於父類構造器
  子類構造器：優先順序低於子類構造程式碼塊
  總結一下優先順序：父類靜態程式碼塊 > 子類靜態程式碼塊 > 父類構造程式碼塊 > 父類構造器 > 子類構造程式碼塊 > 子類構造器

例項

1.預設構造器

新建一個類，不提供任何構造器，編譯器會預設提供一個無參構造器，這就是為什麼沒定義任何構造器，卻可以new 某個物件()

public class People {
    
}

以上這個People類，可以直接通過 new People()來例項化。

2. 禁止物件被外部建立

如果不希望People在外部通過new People()來例項化，只需要將構造器定義為private

public class People {
    private People(){

	}
}

3.構造器過載

過載可以簡單理解為：同個方法名，不同的引數列表。如果希望People能在外部通過new People() 或 new People("字串") 來例項化，則通過以下程式碼即可

public class People {
    //通過new People()呼叫
    public People(){

	}
	//通過new People("字串") 呼叫
	public People(String str){

	}
}

4.構造器的繼承

定義父類構造器，由於該構造器自定義了一個帶參構造器，覆蓋了預設的無參構造器，所以不能直接 new SuperClass() 呼叫了，除非再定義一個無參構造器

/**
 * 父類構造器
 */
public class SuperClass {
    /**
	 * 自定義帶參構造器
	 */
    public SuperClass(String str){
        System.out.println("父類的帶參構造方法，引數為：" + str);
    }
}

定義子類構造器，繼承SuperClass，由於SuperClass沒有無參構造器，所以必須在子類構造器中通過 super("字串")來呼叫，否則編譯器會報錯

/**
 * 子類構造器
 */
public class SubClass extends SuperClass {
    /**
     * 無參構造器
     */
    public SubClass(){
        //由於SuperClass沒有無參構造器，所以必須在子類構造器中通過 super("字串")來呼叫，否則編譯器會報錯。
        //如果沒定義該句，則編譯器會預設呼叫 super()
		super("");
    }
	/**
     * 帶參構造器
     */
    public SubClass(String subStr){
        //由於SuperClass沒有無參構造器，所以必須在子類構造器中通過 super("字串")來呼叫，否則編譯器會報錯。
        //如果沒定義該句，則編譯器會預設呼叫 super()
		super(subStr);
    }
}

5. 構造器、靜態程式碼塊、構造程式碼塊的執行順序

5.1 無繼承的情況

public class People {
    
    static {
        System.out.println("靜態程式碼塊，程式啟動後執行，只會執行一次");
    }

    /**
     * 預設的無參構造器
     */
    public People(){
        System.out.println("預設構造器");
    }

    /**
     * 構造器過載，自定義一個帶參構造器
     * @param str
     */
    public People(String str){
        System.out.println("帶參構造器，引數：" + str);
    }

    {
        System.out.println("構造程式碼塊，每次呼叫構造方法都會執行一次");
    }
}

例項化People

public static void main(String[] args){
    System.out.println("--------------people----------------");
    People people = new People();
    System.out.println("--------------people1----------------");
    People people1 = new People("張三");
}

執行以上程式碼，輸出：

--------------people----------------
靜態程式碼塊，程式啟動後執行，只會執行一次
構造程式碼塊，每次呼叫構造方法都會執行一次
預設構造器
--------------people1----------------
構造程式碼塊，每次呼叫構造方法都會執行一次
帶參構造器，引數：張三

5.2 有繼承的情況

定義父類SuperClass

/**
 * 父類構造器
 */
public class SuperClass {

    {
        System.out.println("父類構造程式碼塊，每次呼叫構造方法都會執行的");
    }

    /**
     * 父類無參構造方法
     */
    public SuperClass(){
        System.out.println("父類的預設構造方法");
    }

    /**
     * 過載，自定義父類帶參構造方法
     * @param str
     */
    public SuperClass(String str){
        System.out.println("父類的帶參構造方法，引數為：" + str);
    }

    static {
        System.out.println("父類的靜態程式碼塊，程式啟動後執行，只會執行一次");
    }

}

定義子類SubClass，繼承SuperClass

/**
 * 子類構造器，繼承SuperClass
 */
public class SubClass extends SuperClass {

    static {
        System.out.println("子類的靜態程式碼塊，程式啟動後執行，只會執行一次，先執行父類的，再執行子類的");
    }

    {
        System.out.println("子類構造程式碼塊，每次呼叫構造方法都會執行的");
    }

    /**
     * 無參構造器
     */
    public SubClass(){

        //這裡沒有指定呼叫父類哪個構造器，會預設呼叫 super()，呼叫父類的無參構造器public SuperClass()
    }

    /**
     * 過載構造器，多傳兩個引數
     * @param str
     * @param str1
     */
    public SubClass(String str,String str1){
        //必須寫在構造器第一行，呼叫父類構造器 public SuperClass(String str)
        super(str);
        System.out.println("子類帶參構造器：" + str1);
    }
}

例項化SubClass

public static void main(String[] args){
    System.out.println("--------------subClass1----------------");
    SubClass subClass1 = new SubClass();

    System.out.println("--------------subClass2----------------");
    SubClass subClass2 = new SubClass("子類第一個引數","子類第二個引數");

}

執行以上程式碼，輸出：

--------------subClass1----------------
父類的靜態程式碼塊，程式啟動後執行，只會執行一次
子類的靜態程式碼塊，程式啟動後執行，只會執行一次，先執行父類的，再執行子類的
父類構造程式碼塊，每次呼叫構造方法都會執行的
父類的預設構造方法
子類構造程式碼塊，每次呼叫構造方法都會執行的
--------------subClass2----------------
父類構造程式碼塊，每次呼叫構造方法都會執行的
父類的帶參構造方法，引數為：子類第一個引數
子類構造程式碼塊，每次呼叫構造方法都會執行的
子類帶參構造器：子類第二個引數