java構造方法

重載構造方法 、默認構造方法、子類調用父類的構造方法、構造方法的做用域、構造方法的訪問級別

在多數狀況下，初始化一個對象的最終步驟是去調用這個對象的構造方法。構造方法負責對象的初始化工做，爲實例變量賦予合適的初始值。構造方法必須知足如下語法規則：

(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返回類型，所以是普通的實例方法：

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();

}

}

以上程序的打印結果爲null。由於用new語句建立Mystery實例時，調用的是Mystery類的默認構造方法，而不是以上有void返回類型的Mystery()方法。

 重載構造方法

當經過new語句建立一個對象時，在不一樣的條件下，對象可能會有不一樣的初始化行爲。例如對於公司新進來的一個僱員，在一開始的時候，有可能他的姓名和年齡是未知的，也有可能僅僅他的姓名是已知的，也有可能姓名和年齡都是已知的。若是姓名是未知的，就暫且把姓名設爲"無名氏"，若是年齡是未知的，就暫且把年齡設爲-1。

可經過重載構造方法來表達對象的多種初始化行爲。如下例程的Employee類的構造方法有三種重載形式。在一個類的多個構造方法中，可能會出現一些重複操做。爲了提升代碼的可重用性，Java語言容許在一個構造方法中，用this語句來調用另外一個構造方法。

例程 Employee.java

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;}

}

如下程序分別經過三個構造方法建立了三個Employee對象：

Employee zhangsan=new Employee("張三",25);

Employee lisi=new Employee("李四");

Employee someone=new Employee();

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

用this語句來調用其餘構造方法時，必須遵照如下語法規則：

（1）假如在一個構造方法中使用了this語句，那麼它必須做爲構造方法的第一條語句（不考慮註釋語句）。

如下構造方法是非法的：

public Employee(){

String name="無名氏";

this(name); //編譯錯誤，this語句必須做爲第一條語句

}

（2）只能在一個構造方法中用this語句來調用類的其餘構造方法，而不能在實例方法中用this語句來調用類的其餘構造方法。

（3）只能用this語句來調用其餘構造方法，而不能經過方法名來直接調用構造方法。

如下對構造方法的調用方式是非法的：

public Employee() {

String name= "無名氏";

Employee(name); //編譯錯誤，不能經過方法名來直接調用構造方法

}

 默認構造方法

默認構造方法是沒有參數的構造方法，可分爲兩種：（1）隱含的默認構造方法（2）程序顯式定義的默認構造方法。

在Java語言中，每一個類至少有一個構造方法。爲了保證這一點，若是用戶定義的類中沒有提供任何構造方法，那麼Java語言將自動提供一個隱含的默認構造方法。該構造方法沒有參數，用public 修飾，並且方法體爲空，格式以下：

public ClassName(){} //隱含的默認構造方法

在程序中也能夠顯式的定義默認構造方法，它能夠是任意的訪問級別。例如：

protected Employee() { //程序顯式定義的默認構造方法

this("無名氏");

}

若是類中顯式定義了一個或多個構造方法，而且全部的構造方法都帶參數，那麼這個類就失去了默認構造方法。在如下程序中，Sample1類有一個隱含的默認構造方法，Sample2類沒有默認構造方法，Sample3類有一個顯式定義的默認構造方法：

public class Sample1{}

public class Sample2{

public Sample2(int a){System.out.println("My Constructor");}

}

public class Sample3{

public Sample3(){System.out.println("My Default Constructor");}

}

能夠調用Sample1類的默認構造方法來建立Sample1對象：

Sample1 s=new Sample1(); //合法

Sample2類沒有默認構造方法，所以如下語句會致使編譯錯誤：

Sample2 s=new Sample2(); //編譯出錯

Sample3類顯式定義了默認構造方法，所以如下語句是合法的。

Sample3 s=new Sample3();

子類調用父類的構造方法

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

public class MyException extends Exception{} // MyException類只有一個隱含的默認構造方法

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

public Exception(String msg)

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

//編譯出錯，MyException類不存在這樣的構造方法

Exception e=new MyException("Something is error");

在子類的構造方法中，能夠經過super語句調用父類的構造方法。例如：

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);

}

}

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

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

如下代碼是非法的：

public MyException(String msg){

Exception(msg); //編譯錯誤

}

（2）使用super語句時，必須放在最前面。

如下代碼是非法的：

public MyException(){

String msg= "Something wrong";

super(msg); //編譯錯誤，super語句必須做爲構造方法的第一條語句

}

在建立子類的對象時，Java虛擬機首先執行父類的構造方法，而後再執行子類的構造方法。在多級繼承的狀況下，將從繼承樹的最上層的父類開始，依次執行各個類的構造方法，這能夠保證子類對象從全部直接或間接父類中繼承的實例變量都被正確的初始化。例如如下Base父類和Sub子類分別有一個實例變量 a和b，當構造Sub實例時，這兩個實例變量都會被初始化。

public 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 Base(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

}

}

在如下例程（Son.java）中，Son類繼承Father類，Father類繼承Grandpa類。這三個類都顯式定義了默認的構造方法，此外還定義了一個帶參數的構造方法。

例程Son.java

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(); //②

}

}

執行以上main()方法的第①條語句，打印結果以下：

My Grandpa

My Father

My Son

 

當子類的構造方法沒有用super語句顯式調用父類的構造方法，那麼經過這個構造方法建立子類對象時，Java虛擬機會自動先調用父類的默認構造方法。執行以上Son類的main()方法的第②條語句，打印結果以下：

default Grandpa

default Father

default Son

 

當子類的構造方法沒有用super語句顯式調用父類的構造方法，而父類又沒有提供默認構造方法時，將會出現編譯錯誤。例如把例程Son.java作適當修改，刪除Grandpa類中顯式定義的默認構造方法：

// protected Grandpa(){

// System.out.println("default GrandPa");

// }

這樣，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)構造方法。

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();

}

}

執行以上Sub類的main()方法的new Sub()語句，打印結果以下：

call Base(int i)

call Sub(int i)

call Sub()

 

在下面的例子中，Base類中沒有定義任何構造方法，它實際上有一個隱含的默認構造方法：

Base(){}

Sub類的Sub(int i)構造方法沒有用super語句顯式調用父類的構造方法，所以當建立Sub實例時，會先調用Base父類的隱含默認構造方法。

class Base{} //具備隱含默認構造方法

public class Sub extends Base{

Sub(int i){System.out.println(i);}

public static void main(String args[]){

System.out.println(new Sub(1)); //打印1

}

}

 構造方法的做用域

構造方法只能經過如下方式被調用：

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

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

(3)在程序中經過new語句調用它。

對於例程（Sub.java）的代碼，請讀者本身分析某些語句編譯出錯的緣由。

例程 Sub.java

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); //編譯出錯

}

}

 構造方法的訪問級別

構造方法能夠處於public、protected、默認和private這四種訪問級別之一。本節着重介紹構造方法處於private級別的意義。

當構造方法爲private級別，意味着只能在當前類中訪問它：在當前類的其餘構造方法中能夠經過this語句調用它，此外還能夠在當前類的成員方法中經過new語句調用它。

在如下場合之一，能夠把類的全部構造方法都聲明爲private類型。

（1）在這個類中僅僅包含了一些供其餘程序調用的靜態方法，沒有任何實例方法。其餘程序無需建立該類的實例，就能訪問類的靜態方法。例如 java.lang.Math類就符合這種狀況，在Math類中提供了一系列用於數學運算的公共靜態方法，爲了禁止外部程序建立Math類的實例， Math類的唯一的構造方法是private類型的：

private Math(){}

abstract類型的類也不容許實例化。也許你會問，把Math類定義爲以下abstract類型，不是也能禁止Math類被實例化嗎？

public abstract class Math{…}

若是一個類是抽象類，意味着它是專門用於被繼承的類，能夠擁有子類，並且能夠建立具體子類的實例。而JDK並不但願用戶建立Math類的子類，在這種狀況下，把類的構造方法定義爲private類型更合適。

（2）禁止這個類被繼承。當一個類的全部構造方法都是private類型，假如定義了它的子類，那麼子類的構造方法沒法調用父類的任何構造方法，所以會致使編譯錯誤。把一個類聲明爲final類型，也能禁止這個類被繼承。這二者的區別是：

1)若是一個類容許其餘程序用new語句構造它的實例，但不容許擁有子類，那就把類聲明爲final類型。

2)若是一個類既不容許其餘程序用new語句構造它的實例，又不容許擁有子類，那就把類的全部構造方法聲明爲private類型。

因爲大多數類都容許其餘程序用new語句構造它的實例，所以用final修飾符來禁止類被繼承的作法更常見。

（3）這個類須要把構造自身實例的細節封裝起來，不容許其餘程序經過new語句建立這個類的實例，這個類向其餘程序提供了得到自身實例的靜態方法，這種方法稱爲靜態工廠方法。