在Java與C語言的程式設計中，必須對建立的物件進行物件初始化，Java採用C++所引入的構造器對物件進行初始化，這是一個在建立物件時被自動呼叫的特殊方法。

注意：構造器的名稱必須與類名完全相同

class Constructor{                                //cover from Mr.Summer
Constructor(){  //this is a constructor.
  System.out.println("Constructor");}
}

public class Text{
    public static void main(String[] args){
        for(int i=0;i<3;i++)
            new Constructor();}
}/*Output: Constructor Constructor Constructor*/
 

在建立物件時：

new Constructor( )；

將會為物件自動分配儲存空間，並呼叫對應的構造器，這樣就能確保在使用之前已經初始化了。

構造器有兩種：

①不含任何引數的構造器，即預設構造器；

②含有引數的構造器，如下所示：

class Constructor2{
Constructor2(int i){
    System.out.println("Constructor "+i+" ");  }
}

public class Text2{
    public static void main(String[] args){
        for(int i=0;i<3;i++)
            new Constructor2(i);}
}/*Output:  Constructor 0 Constructor 1 Constructor 2*/
 

構造器的過載：

前面已經說明了構造器的名稱必須與類名相同，如果想用多種方式建立一個物件該怎麼辦？假設你建立一個類，既可以用標準方式進行初始化，又可以從檔案中讀取所需要的資訊來初始化，這就需要兩個構造器：一個預設構造器，一個帶變數的構造器。這就必須用到構造器的過載。

下面這個例子同時示範了過載的構造器和過載的方法：

class Tree{                                        //cover from Thinking in Java
    int height;
    Tree(){
        System.out.println("Planting a seedling");
        height = 0;}

    Tree(int i){
        height = i;
        System.out.println("Creating new Tree that is " + height + " feet tall");}

    void info(){
        System.out.println("Tree is " + height + " feet tall");}
    
    void info(String s){
        System.out.println(s+":Tree is " + height + " feet tall");}

}

public class Test{
    public static void main(String[] args){
        for(int i = 0 ; i < 3 ; i++) {
            Tree t = new Tree(i);
            t.info();
            t.info("overloaded method");}
        new Tree();
}
}/*Output
Creating new Tree that is 0 feet tall
Tree is 0 feet tall
overloaded method:Tree is 0 feet tall
Creating new Tree that is 1 feet tall
Tree is 1 feet tall
overloaded method:Tree is 1 feet tall
Creating new Tree that is 2 feet tall
Tree is 2 feet tall
overloaded method:Tree is 2 feet tall
Planting a seedling*/

 

過載構造器還能夠通過引數進行區分，規則很簡單，因為在Java中，任何過載的方法都必須有一個獨一無二的引數型別列表，例如：

Tree（int，string）與Tree（string，int）是兩個不同的過載構造器

this 在構造器中的用法

public class Money{
    int i = 0;
    String s = "hello";
    
Money(int i){
    System.out.println("you have "+i+" dollar.");}

Money(String ss){
    System.out.println(ss+" ,nice to meet you.");
    s = ss;}

Money(String s,int i){
    this(i);
    this.s=s;
    System.out.println("go Money(String s,int i)");}

Money(){
    this("hi" , 10);
    System.out.println("go Money( )");}

public static void main(String[] args){
    Money m = new Money();} 

}/*Output 
you have 10 dollar.
Go Money(String s, int i)
Go Money( )*/

主函式中建立一個物件，物件首先呼叫Money（）函式，因為Money（）函式中的this( " hi " , " 10 " )是指向Money(s , i )型別的構造器，在該構造器中又有一個指向Money（i）型別的構造器，所以先執行Money（i），再執行Money(s , i )，最後執行Money（）。

this再這裡的的用法就是明確指向某個構造器，方便呼叫

super 在構造器中的用法

super( )函式在構造器中的呼叫指的是在子類中呼叫父類的構造器函式。this則不同，this不能用於子類呼叫父類的構造器，只能呼叫同一個類中的構造器。

class Super {
	Super(String a){
		System.out.println("引數為a的構造器");
	}
		
	Super() {
		System.out.println("empty 引數");
	}
	public static class classa extends Super{
		classa() {
		super();
		}
		classa(String a){
			super(a);
		}
	}
	
	public static void main(String[] args) {
				classa a = new classa();
				a=new classa();
				a=new classa("a");			
	}
}/*empty 引數
empty 引數
引數為a的構造器*/

可以看到在classa中呼叫 super( )與super(a) 兩個構造器,在建立classa物件時呼叫classa（），classa（）又使用super（）呼叫父類中無引數構造器Super( )，同樣的classa（"a"）則利用super（a）呼叫父類中的Super(String a)構造器。

初始化的順序是先靜態（static）物件，再非靜態物件，只是初始化，並不執行靜態函式！