JavaSE入門學習23：Java物件導向之構造方法

JavaSE入門學習23：Java物件導向之構造方法

學了JavaSE物件導向這一部分，也該對構造方法做一個總結了。

一構造方法

在多數情況下，初始化一個對象的最終步驟是去調用這個對象的構造方法。構造方法負責對象的初始化工作，為

執行個體變數賦予合適的初始值。構造方法必須滿足以下文法規則：

(1)方法名必須與類名相同；

(2)不要聲明傳回型別；

(3)不能被static、final、synchronized、abstract和native修飾。構造方法不能被子類繼承，所以用final和abstract

修飾沒有意義。構造方法用於初始化一個建立的對象，所以用static修飾沒有意義。多個線程不會同時建立記憶體位址相

同的同一個對象，因此用synchronized修飾沒有必要。此外，Java語言不支援native類型的構造方法。

執行個體：在以下Sample類中，具有int傳回型別的Sample(int x)方法只是個普通的執行個體方法，不能作為構造方法：

 

public class Sample {    private int x;    //不帶參數的構造方法    public Sample(){this(1);    }    //帶參數的構造方法    public Sample(int x) {         this.x=x;    }    //不是構造方法，是一般的執行個體方法    public int Sample(int x) {         return x++;    }}

 

以上例子儘管能編譯通過，但是把執行個體方法和構造方法同名，不是好的編程習慣，容易引起混淆。

執行個體：以下Mystery類的Mystery()方法有void傳回型別，因此是普通的執行個體方法：

<span style="font-size:18px;">public class Mystery {private String s;//不是構造方法public void Mystery(){s = "constructor";}        void go() {System.out.println(s);        }        public static void main(String[] args) {Mystery m = new Mystery();                m.go();        }}</span>

 

以上程式的列印結果為null。因為用new語句建立Mystery執行個體時，調用的是Mystery類的預設構造方法，而不是以

上有void傳回型別的Mystery()方法。

二重載構造方法

當通過new語句建立一個對象時，在不同的條件下，對象可能會有不同的初始化行為。可通過重載構造方法來表

達對象的多種初始化行為。以下的Employee類的構造方法有三種重載形式。在一個類的多個構造方法中，可能會出現

一些重複操作。為了提高代碼的可重用性，Java語言允許在一個構造方法中，用this語句來調用另一個構造方法。

例如對於公司新進來的一個僱員，在一開始的時候，有可能他的姓名和年齡是未知的，也有可能僅僅他的姓名是

已知的，也有可能姓名和年齡都是已知的。如果姓名是未知的，就暫且把姓名設為"無名氏"，如果年齡是未知的，就

暫且把年齡設為-1。

執行個體：Employee.java源檔案代碼：

 

<span style="font-size:18px;">public class Employee {    private String name;    private int age;    //當僱員的姓名和年齡都已知，就調用此構造方法    public Employee(String name, int age) {this.name = name;        this.age=age;    }    //當僱員的姓名已知而年齡未知，就調用此構造方法    public Employee(String name) {this(name, -1);    }    //當僱員的姓名和年齡都未知，就調用此構造方法     public Employee() {this( "無名氏" );    }    public void setName(String name){this.name=name;     }    public String getName(){return name;     }    public void setAge(int age){this.age=age;    }    public int getAge(){return age;    }   public static void main(String[] args){Employee zhangsan=new Employee("張三",25);        Employee lisi=new Employee("李四");        Employee someone=new Employee();   }}</span>

 

上述程式中mian()方法分別通過三個構造方法建立了三個Employee對象。在Employee(String name)構造方法

中，this(name,-1)語句用於調用Employee(String name,int age)構造方法。在Employee()構造方法中，this("無名氏")

語句用於調用Employee(String name)構造方法。

用this語句來調用其他構造方法時，必須遵守以下文法規則：

(1)假如在一個構造方法中使用了this語句，那麼它必須作為構造方法的第一條語句(不考慮備註陳述式)。以下構造方

法是非法的：

<span style="font-size:18px;">public Employee(){      String name="無名氏";      this(name);//編譯錯誤，this語句必須作為第一條語句}</span>

(2)只能在一個構造方法中用this語句來調用類的其他構造方法，而不能在執行個體方法中用this語句來調用類的其他構

造方法。

(3)只能用this語句來調用其他構造方法，而不能通過方法名來直接調用構造方法。以下對構造方法的調用方式是

非法的：

<span style="font-size:18px;">public Employee() {         String name= "無名氏";         Employee(name); //編譯錯誤，不能通過方法名來直接調用構造方法}</span>

三預設構造方法

預設構造方法是沒有參數的構造方法，可分為兩種：

a隱含的預設構造方法；

b程式顯式定義的預設構造方法。

在Java語言中，每個類至少有一個構造方法。為了保證這一點，如果使用者定義的類中沒有提供任何構造方法，那

麼Java語言將自動提供一個隱含的預設構造方法。該構造方法沒有參數，用public 修飾，而且方法體為空白，格式為：

<span style="font-size:18px;">//隱含的預設構造方法public ClassName(){} </span>

在程式中也可以顯式的定義預設構造方法，它可以是任意的存取層級。例如：

<span style="font-size:18px;">//程式顯式定義的預設構造方法protected Employee() { this("無名氏");}</span>

如果類中顯式定義了一個或多個構造方法，並且所有的構造方法都帶參數，那麼這個類就失去了預設構造方法。

在以下程式中，Sample1類有一個隱含的預設構造方法，Sample2類沒有預設構造方法，Sample3類有一個顯式定義

的預設構造方法：

<span style="font-size:18px;">class Sample1{ }class Sample2{       public Sample2(int a){            System.out.println("My Constructor");      }}class Sample3{       public Sample3(){              System.out.println("My Default Constructor");       }}</span>

可以調用Sample1類的預設構造方法來建立Sample1對象：Sample1 s=new Sample1(); //合法

Sample2類沒有預設構造方法，因此以下語句會導致編譯錯誤：Sample2 s=new Sample2(); //編譯出錯

Sample3類顯式定義了預設構造方法，因此以下語句是合法的。Sample3 s=new Sample3();

四子類調用父類的構造方法

父類的構造方法不能被子類繼承。以下MyException類繼承了java.lang.Exception類：

<span style="font-size:18px;">// MyException類只有一個隱含的預設構造方法public class MyException extends Exception{} </span>

儘管在Exception類中定義了如下形式的構造方法：

<span style="font-size:18px;">public Exception(String msg){}</span>

但MyException類不會繼承以上Exception類的構造方法，因此以下代碼是不合法的：

<span style="font-size:18px;">Exception e=new MyException("Something is error");//編譯出錯，MyException類不存在這樣的構造方法</span>

在子類的構造方法中，可以通過super語句調用父類的構造方法。例如：

<span style="font-size:18px;">public class MyException extends Exception{        public MyException(){              //調用Exception父類的Exception(String msg)構造方法              super("Something is error");       }       public MyException(String msg){             //調用Exception父類的Exception(String msg)構造方法             super(msg);       }}</span>

用super語句來調用父類的構造方法時，必須遵守以下文法規則。

(1)在子類的構造方法中，不能直接通過父類方法名調用父類的構造方法，而是要使用super語句。

以下代碼是非法的：

<span style="font-size:18px;">public MyException(String msg){       Exception(msg); //編譯錯誤}</span>

(2)用super語句時，必須放在最前面。

以下代碼是非法的：

<span style="font-size:18px;">public MyException(){        String msg= "Something wrong";        super(msg); //編譯錯誤，super語句必須作為構造方法的第一條語句}</span>

在建立子類的對象時，Java虛擬機器首先執行父類的構造方法，然後再執行子類的構造方法。在多級繼承的情況

下，將從繼承樹的最上層的父類開始，依次執行各個類的構造方法，這可以保證子類對象從所有直接或間接父類中繼

承的執行個體變數都被正確的初始化。例如以下Base父類和Sub子類分別有一個執行個體變數 a和b，當構造Sub執行個體時，這兩

個執行個體變數都會被初始化。

執行個體代碼：

 

<span style="font-size:18px;">class Base{private int a;        public Base(int a){this.a=a;}        public int getA(){return a;}}public class Sub extends Base{private int b;        public Sub(int a,int b){super(a); this.b=b;}        public int getB(){return b;}        public static void main(String args[]){Sub sub=new Sub(1,2);                System.out.println("a="+sub.getA()+",b="+sub.getB()); //列印a=1 b=2       }}</span>

 

運行結果：

a=1,b=2

在以下面的執行個體中，Son類繼承Father類，Father類繼承Grandpa類。這三個類都顯式定義了預設的構造方法，此

外還定義了一個帶參數的構造方法。

Son.java源檔案代碼：

<span style="font-size:18px;">class Grandpa{    protected Grandpa(){        System.out.println("default Grandpa");    }    public Grandpa(String name){                System.out.println(name);    }}class Father extends Grandpa{    protected Father(){System.out.println("default Father");    }    public Father(String grandpaName,String fatherName){super(grandpaName);System.out.println(fatherName);    }}public class Son extends Father{    public Son(){System.out.println("default Son");    }    public Son(String grandpaName,String fatherName,String sonName){super(grandpaName,fatherName);System.out.println(sonName);    }    public static void main(String args[]){Son s1= new Son("My Grandpa", "My Father", "My Son");                 Son s2=new Son();    }}</span>

程式運行結果如下：

當子類的構造方法沒有用super語句顯式調用父類的構造方法，那麼通過這個構造方法建立子類對象時，Java虛

擬機會自動先調用父類的預設構造方法。

當子類的構造方法沒有用super語句顯式調用父類的構造方法，而父類又沒有提供預設構造方法時，將會出現編

譯錯誤。我們注釋掉Grandpa類的protected層級的構造方法，這樣，Grandpa類就失去了預設構造方法，這時，在編

譯Father類的預設構造方法時，因為找不到Grandpa類的預設構造方法而編譯出錯。如果把Grandpa類的預設構造方

法的protected存取層級改為private存取層級，也會導致編譯錯誤，因為Father類的預設構造方法無法訪問Grandpa類

的私人預設構造方法。

在以下例子中，子類Sub的預設構造方法沒有通過super語句調用父類的構造方法，而是通過this語句調用了自身

的另一個構造方法Sub(int i)，而在Sub(int i)中通過super語句調用了父類Base的Base(int i)構造方法。這樣，無論通過

Sub類的哪個構造方法來建立Sub執行個體，都會先調用父類Base的Base(int i)構造方法。

Sub.java源檔案代碼：

 

<span style="font-size:18px;">class Base{Base(int i){System.out.println("call Base(int i)");}}public class Sub extends Base{Sub(){this(0); System.out.println("call Sub()");}       Sub(int i){super(i); System.out.println("call Sub(int i)");}       public static void main(String args[]){                Sub sub=new Sub();       }}</span>

程式執行結果如下：

五構造方法的範圍

構造方法只能通過以下方式被調用：

(1)當前類的其他構造方法通過this語句調用它。

(2)當前類的子類的構造方法通過super語句調用它。

(3)在程式中通過new語句調用它。

注意下面的建構函式的調用的方式：

Sub.java源檔案代碼：

 

<span style="font-size:18px;">class Base{    public Base(int i,int j){    }    public Base(int i){this(i,0); //合法        Base(i,0); //編譯出錯    }}class Sub extends Base{    public Sub(int i,int j){super(i,0); //合法    }    void method1(int i,int j){this(i,j); //編譯出錯Sub(i,j); //編譯出錯    }    void method2(int i,int j){super(i,j); //編譯出錯    }    void method3(int i,int j){Base s=new Base(0,0); //合法s.Base(0,0); //編譯出錯    }}</span>

六構造方法的存取層級

構造方法可以處於public、protected、預設和private這四種存取層級之一。本節著重介紹構造方法處於private級

別的意義。當構造方法為private層級，意味著只能在當前類中訪問它：在當前類的其他構造方法中可以通過this語句

調用它，此外還可以在當前類的成員方法中通過new語句調用它。

在以下場合之一，可以把類的所有構造方法都聲明為private類型：

(1)在這個類中僅僅包含了一些供其他程式調用的靜態方法，沒有任何執行個體方法。其他程式無需建立該類的執行個體，

就能訪問類的靜態方法。例如 java.lang.Math類就符合這種情況，在Math類中提供了一系列用於數學運算的公用靜態

方法，為了禁止外部程式建立Math類的執行個體， Math類的惟一的構造方法是private類型的：private Math(){}

如果一個類是抽象類別，意味著它是專門用於被繼承的類，可以擁有子類，而且可以建立具體子類的執行個體。而JDK

並不希望使用者建立Math類的子類，在這種情況下，把類的構造方法定義為private類型更合適。

(2)禁止這個類被繼承。當一個類的所有構造方法都是private類型，假如定義了它的子類，那麼子類的構造方法無

法調用父類的任何構造方法，因此會導致編譯錯誤。把一個類聲明為final類型，也能禁止這個類被繼承。這兩者的區

別是：

A如果一個類允許其他程式用new語句構造它的執行個體，但不允許擁有子類，那就把類聲明為final類型。

B如果一個類既不允許其他程式用new語句構造它的執行個體，又不允許擁有子類，那就把類的所有構造方法聲明為

private類型。由於大多數類都允許其他程式用new語句構造它的執行個體，因此用final修飾符來禁止類被繼承的做法更常

見。

C這個類需要把構造自身執行個體的細節封裝起來，不允許其他程式通過new語句建立這個類的執行個體，這個類向其他

程式提供了獲得自身執行個體的靜態方法，這種方法稱為靜態Factory 方法。