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語句創建這個類的實例，這個類向其他程序提供了獲得自身實例的靜態方法，這種方法稱為靜態工廠方法。