在多數(shù)情況下，初始化一個對象的最終步驟是去調(diào)用這個對象的構(gòu)造方法箕般。構(gòu)造方法負責(zé)對象的初始化工作瘤泪，為實例變量賦予合適的初始值。構(gòu)造方法必須滿足以下語法規(guī)則：
(1) 方法名必須與類名相同货矮。
(2)不要聲明返回類型。
(3)不能被static斯够、final囚玫、synchronized喧锦、abstract和native修飾。構(gòu)造方法不能被子類繼承抓督，所以用final和
abstract修飾沒有意義燃少。構(gòu)造方法用于初始化一個新建的對象，所以用static修飾沒有意義铃在。多個線程不會同時創(chuàng)建內(nèi)存地址相同的同一個對象阵具，因此用synchronized修飾沒有必要。此外定铜，Java語言不支持native類型的構(gòu)造方法阳液。
在以下Sample類中，具有int返回類型的Sample(int x)方法只是個普通的實例方法揣炕，不能作為構(gòu)造方法：
public class Sample {
private int x;
public Sample() { // 不帶參數(shù)的構(gòu)造方法
this(1);
}
public Sample(int x) { //帶參數(shù)的構(gòu)造方法
this.x=x;
}
public int Sample(int x) { //不是構(gòu)造方法
return x++;
}
}
以上例子盡管能編譯通過帘皿，但是把實例方法和構(gòu)造方法同名，不是好的編程習(xí)慣畸陡，容易引起混淆鹰溜。例如以下Mystery類的Mystery()方法有void返回類型，因此是普通的實例方法：
public class Mystery {
private String s;
public void Mystery() { //不是構(gòu)造方法
s = "constructor";
}
void go() {
System.out.println(s);
}
public static void main(String[] args) {
Mystery m = new Mystery();
m.go();
}
}
以上程序的打印結(jié)果為null丁恭。因為用new語句創(chuàng)建Mystery實例時曹动，調(diào)用的是Mystery類的默認構(gòu)造方法，而不是以上有void返回類型的Mystery()方法牲览。
重載構(gòu)造方法
當(dāng)通過new語句創(chuàng)建一個對象時墓陈，在不同的條件下，對象可能會有不同的初始化行為竭恬。例如對于公司新進來的一個雇員跛蛋，在一開始的時候熬的，有可能他的姓名和年齡是未知的痊硕，也有可能僅僅他的姓名是已知的，也有可能姓名和年齡都是已知的押框。如果姓名是未知的岔绸，就暫且把姓名設(shè)為"無名氏"，如果年齡是未知的橡伞，就暫且把年齡設(shè)為-1盒揉。
可通過重載構(gòu)造方法來表達對象的多種初始化行為。以下例程的Employee類的構(gòu)造方法有三種重載形式兑徘。在一個類的多個構(gòu)造方法中刚盈，可能會出現(xiàn)一些重復(fù)操作。為了提高代碼的可重用性挂脑，Java語言允許在一個構(gòu)造方法中藕漱，用this語句來調(diào)用另一個構(gòu)造方法欲侮。
例程 Employee.java
public class Employee {
private String name;
private int age;
/** 當(dāng)雇員的姓名和年齡都已知，就調(diào)用此構(gòu)造方法 */
public Employee(String name, int age) {
this.name = name;
this.age=age;
}
/** 當(dāng)雇員的姓名已知而年齡未知肋联，就調(diào)用此構(gòu)造方法 */
public Employee(String name) {
this(name, -1);
}
/** 當(dāng)雇員的姓名和年齡都未知威蕉，就調(diào)用此構(gòu)造方法 */
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;}
}
以下程序分別通過三個構(gòu)造方法創(chuàng)建了三個Employee對象：
Employee zhangsan=new Employee("張三",25);
Employee lisi=new Employee("李四");
Employee someone=new Employee();
在Employee(String name)構(gòu)造方法中，this(name,-1)語句用于調(diào)用Employee(String name,int age)構(gòu)造方法橄仍。在Employee()構(gòu)造方法中韧涨，this("無名氏")語句用于調(diào)用Employee(String name)構(gòu)造方法。
用this語句來調(diào)用其他構(gòu)造方法時侮繁，必須遵守以下語法規(guī)則：
（1）假如在一個構(gòu)造方法中使用了this語句虑粥，那么它必須作為構(gòu)造方法的第一條語句（不考慮注釋語句）。
以下構(gòu)造方法是非法的：
public Employee(){
String name="無名氏";
this(name); //編譯錯誤宪哩，this語句必須作為第一條語句
}
（2）只能在一個構(gòu)造方法中用this語句來調(diào)用類的其他構(gòu)造方法舀奶，而不能在實例方法中用this語句來調(diào)用類的其他構(gòu)造方法。
（3）只能用this語句來調(diào)用其他構(gòu)造方法斋射，而不能通過方法名來直接調(diào)用構(gòu)造方法育勺。
以下對構(gòu)造方法的調(diào)用方式是非法的：
public Employee() {
String name= "無名氏";
Employee(name); //編譯錯誤叨橱，不能通過方法名來直接調(diào)用構(gòu)造方法
}
默認構(gòu)造方法
默認構(gòu)造方法是沒有參數(shù)的構(gòu)造方法烁登，可分為兩種：（1）隱含的默認構(gòu)造方法（2）程序顯式定義的默認構(gòu)造方法褂乍。
在Java語言中料按，每個類至少有一個構(gòu)造方法狐蜕。為了保證這一點尾抑，如果用戶定義的類中沒有提供任何構(gòu)造方法芭商，那么Java語言將自動提供一個隱含的默認構(gòu)造方法语盈。該構(gòu)造方法沒有參數(shù)哑了，用public 修飾赘方，而且方法體為空，格式如下：
public ClassName(){} //隱含的默認構(gòu)造方法
在程序中也可以顯式的定義默認構(gòu)造方法弱左，它可以是任意的訪問級別窄陡。例如：
protected Employee() { //程序顯式定義的默認構(gòu)造方法
this("無名氏");
}
如果類中顯式定義了一個或多個構(gòu)造方法，并且所有的構(gòu)造方法都帶參數(shù)拆火，那么這個類就失去了默認構(gòu)造方法跳夭。在以下程序中，Sample1類有一個隱含的默認構(gòu)造方法们镜，Sample2類沒有默認構(gòu)造方法币叹，Sample3類有一個顯式定義的默認構(gòu)造方法：
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");}
}
可以調(diào)用Sample1類的默認構(gòu)造方法來創(chuàng)建Sample1對象：
Sample1 s=new Sample1(); //合法
Sample2類沒有默認構(gòu)造方法，因此以下語句會導(dǎo)致編譯錯誤：
Sample2 s=new Sample2(); //編譯出錯
Sample3類顯式定義了默認構(gòu)造方法模狭，因此以下語句是合法的颈抚。
Sample3 s=new Sample3();
子類調(diào)用父類的構(gòu)造方法
父類的構(gòu)造方法不能被子類繼承。以下MyException類繼承了java.lang.Exception類：
public class MyException extends Exception{} // MyException類只有一個隱含的默認構(gòu)造方法
盡管在Exception類中定義了如下形式的構(gòu)造方法：
public Exception(String msg)
但MyException類不會繼承以上Exception類的構(gòu)造方法嚼鹉，因此以下代碼是不合法的：
//編譯出錯贩汉，MyException類不存在這樣的構(gòu)造方法
Exception e=new MyException("Something is error");
在子類的構(gòu)造方法中九妈，可以通過super語句調(diào)用父類的構(gòu)造方法。例如：
public class MyException extends Exception{
public MyException(){
//調(diào)用Exception父類的Exception(String msg)構(gòu)造方法
super("Something is error");
}
public MyException(String msg){
//調(diào)用Exception父類的Exception(String msg)構(gòu)造方法
super(msg);
}
}
用super語句來調(diào)用父類的構(gòu)造方法時雾鬼，必須遵守以下語法規(guī)則萌朱。
（1）在子類的構(gòu)造方法中，不能直接通過父類方法名調(diào)用父類的構(gòu)造方法策菜，而是要使用super語句晶疼。
以下代碼是非法的：
public MyException(String msg){
Exception(msg); //編譯錯誤
}
（2）使用super語句時，必須放在最前面又憨。
以下代碼是非法的：
public MyException(){
String msg= "Something wrong";
super(msg); //編譯錯誤翠霍，super語句必須作為構(gòu)造方法的第一條語句
}
在創(chuàng)建子類的對象時，Java虛擬機首先執(zhí)行父類的構(gòu)造方法蠢莺，然后再執(zhí)行子類的構(gòu)造方法寒匙。在多級繼承的情況下，將從繼承樹的最上層的父類開始躏将，依次執(zhí)行各個類的構(gòu)造方法锄弱，這可以保證子類對象從所有直接或間接父類中繼承的實例變量都被正確的初始化。例如以下Base父類和Sub子類分別有一個實例變量 a和b祸憋，當(dāng)構(gòu)造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類掸鹅，F(xiàn)ather類繼承Grandpa類。這三個類都顯式定義了默認的構(gòu)造方法拦赠，此外還定義了一個帶參數(shù)的構(gòu)造方法巍沙。
例程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(); //②
}
}
執(zhí)行以上main()方法的第①條語句，打印結(jié)果如下：
My Grandpa
My Father
My Son
當(dāng)子類的構(gòu)造方法沒有用super語句顯式調(diào)用父類的構(gòu)造方法荷鼠，那么通過這個構(gòu)造方法創(chuàng)建子類對象時句携，Java虛擬機會自動先調(diào)用父類的默認構(gòu)造方法。執(zhí)行以上Son類的main()方法的第②條語句颊咬，打印結(jié)果如下：
default Grandpa
default Father
default Son
當(dāng)子類的構(gòu)造方法沒有用super語句顯式調(diào)用父類的構(gòu)造方法务甥，而父類又沒有提供默認構(gòu)造方法時牡辽，將會出現(xiàn)編譯錯誤喳篇。例如把例程Son.java做適當(dāng)修改，刪除Grandpa類中顯式定義的默認構(gòu)造方法：
// protected Grandpa(){
// System.out.println("default GrandPa");
// }
這樣态辛，Grandpa類就失去了默認構(gòu)造方法麸澜，這時，在編譯Father類的默認構(gòu)造方法時奏黑，因為找不到Grandpa類的默認構(gòu)造方法而編譯出錯炊邦。如果把Grandpa類的默認構(gòu)造方法的protected訪問級別改為private訪問級別编矾，也會導(dǎo)致編譯錯誤，因為Father類的默認構(gòu)造方法無法訪問Grandpa類的私有默認構(gòu)造方法馁害。
在以下例子中窄俏，子類Sub的默認構(gòu)造方法沒有通過super語句調(diào)用父類的構(gòu)造方法，而是通過this語句調(diào)用了自身的另一個構(gòu)造方法Sub(int i)碘菜，而在Sub(int i)中通過super語句調(diào)用了父類Base的Base(int i)構(gòu)造方法凹蜈。這樣，無論通過Sub類的哪個構(gòu)造方法來創(chuàng)建Sub實例忍啸，都會先調(diào)用父類Base的Base(int i)構(gòu)造方法仰坦。
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();
}
}
執(zhí)行以上Sub類的main()方法的new Sub()語句，打印結(jié)果如下：
call Base(int i)
call Sub(int i)
call Sub()
在下面的例子中计雌，Base類中沒有定義任何構(gòu)造方法悄晃，它實際上有一個隱含的默認構(gòu)造方法：
Base(){}
Sub類的Sub(int i)構(gòu)造方法沒有用super語句顯式調(diào)用父類的構(gòu)造方法，因此當(dāng)創(chuàng)建Sub實例時凿滤，會先調(diào)用Base父類的隱含默認構(gòu)造方法妈橄。
class Base{} //具有隱含默認構(gòu)造方法
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
}
}
構(gòu)造方法的作用域
構(gòu)造方法只能通過以下方式被調(diào)用：
(1) 當(dāng)前類的其他構(gòu)造方法通過this語句調(diào)用它。
(2) 當(dāng)前類的子類的構(gòu)造方法通過super語句調(diào)用它翁脆。
(3)在程序中通過new語句調(diào)用它眷细。
對于例程（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); //編譯出錯
}
}
構(gòu)造方法的訪問級別
構(gòu)造方法可以處于public溪椎、protected、默認和private這四種訪問級別之一恬口。本節(jié)著重介紹構(gòu)造方法處于private級別的意義校读。
當(dāng)構(gòu)造方法為private級別，意味著只能在當(dāng)前類中訪問它：在當(dāng)前類的其他構(gòu)造方法中可以通過this語句調(diào)用它祖能，此外還可以在當(dāng)前類的成員方法中通過new語句調(diào)用它歉秫。
在以下場合之一，可以把類的所有構(gòu)造方法都聲明為private類型养铸。
（1）在這個類中僅僅包含了一些供其他程序調(diào)用的靜態(tài)方法雁芙，沒有任何實例方法。其他程序無需創(chuàng)建該類的實例钞螟，就能訪問類的靜態(tài)方法兔甘。例如 java.lang.Math類就符合這種情況，在Math類中提供了一系列用于數(shù)學(xué)運算的公共靜態(tài)方法鳞滨，為了禁止外部程序創(chuàng)建Math類的實例洞焙， Math類的惟一的構(gòu)造方法是private類型的：
private Math(){}
abstract類型的類也不允許實例化。也許你會問，把Math類定義為如下abstract類型澡匪，不是也能禁止Math類被實例化嗎熔任？
public abstract class Math{…}
如果一個類是抽象類，意味著它是專門用于被繼承的類唁情，可以擁有子類疑苔，而且可以創(chuàng)建具體子類的實例。而JDK并不希望用戶創(chuàng)建Math類的子類甸鸟，在這種情況下夯巷，把類的構(gòu)造方法定義為private類型更合適。
（2）禁止這個類被繼承哀墓。當(dāng)一個類的所有構(gòu)造方法都是private類型趁餐，假如定義了它的子類，那么子類的構(gòu)造方法無法調(diào)用父類的任何構(gòu)造方法篮绰，因此會導(dǎo)致編譯錯誤后雷。把一個類聲明為final類型，也能禁止這個類被繼承吠各。這兩者的區(qū)別是：
1)如果一個類允許其他程序用new語句構(gòu)造它的實例臀突，但不允許擁有子類，那就把類聲明為final類型贾漏。
2)如果一個類既不允許其他程序用new語句構(gòu)造它的實例候学，又不允許擁有子類，那就把類的所有構(gòu)造方法聲明為private類型纵散。
由于大多數(shù)類都允許其他程序用new語句構(gòu)造它的實例梳码，因此用final修飾符來禁止類被繼承的做法更常見。
（3）這個類需要把構(gòu)造自身實例的細節(jié)封裝起來伍掀，不允許其他程序通過new語句創(chuàng)建這個類的實例掰茶，這個類向其他程序提供了獲得自身實例的靜態(tài)方法，這種方法稱為靜態(tài)工廠方法蜜笤。
原文地址：http://blog.163.com/bt_q/blog/static/119266729201031754724496/
