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