java 中構造器的調用順序

構造器的調用順序：

step1: 調用基類構造器，首先是根，然後是下一層的導出類，直至最底層的導出類。

step2:按聲明順序調用成員的初始化方法。

step3：調用導出類構造器的主體。

還是用代碼說明吧：

/**
 * 構造器的調用順序
 */
package sandwich;
import static org.print.Print.*;//自己寫的print包

class Meal {
Meal() { print("Meal()"); }
}

class Bread {
Bread() { print("Bread()"); }
}

class Cheese {
Cheese() { print("Cheese()"); }
}

class Lettuce {
Lettuce() { print("Lettuce()"); }
}

class Pickle{
	Pickle(){print("Pickle()");}
}
class Lunch extends Meal {
Lunch() { print("Lunch()"); }
}

class PortableLunch extends Lunch {
PortableLunch() { print("PortableLunch()");}
}

public class Sandwich extends PortableLunch {
private Bread b = new Bread();
private Cheese c = new Cheese();
private Lettuce l = new Lettuce();
public Sandwich() { print("Sandwich()"); }
public static void main(String[] args) {
 new Sandwich();
}
private Pickle p=new Pickle();
} 

上述代碼的運行結果：

Meal()
Lunch()
PortableLunch()
Bread()
Cheese()
Lettuce()
Pickle()
Sandwich()

然鵝，當在構造器中創建了一個對象，但是該對象的所屬的類是導出類。 因爲在初始化對象，調用對象的構造器的時候，導出類並沒有初始化。 。。。

還是用代碼說明吧：

class Glyph {
  void draw() { System.out.println("Glyph.draw()"); }
  Glyph() {
     System.out.println("Glyph() before draw()");
    draw();
     System.out.println("Glyph() after draw()");
  }
}	

class RoundGlyph extends Glyph {
  private int radius = 1;  //radius 是1 ！
  RoundGlyph(int r) {
    radius = r;
     System.out.println("RoundGlyph.RoundGlyph(), radius = " + radius);
  }
  void draw() {
     System.out.println("RoundGlyph.draw(), radius = " + radius);
  }
}	

public class PolyConstructors {
  public static void main(String[] args) {
    new RoundGlyph(5);
  }
}

運行結果：

Glyph() before draw()
RoundGlyph.draw(), radius = 0   //         radius是0！
Glyph() after draw()
RoundGlyph.RoundGlyph(), radius = 5

so, RoundGlyph.draw() 覆蓋了Glyph().draw() 的方法，但是，基類構造器在導出類構造器調用之前調用，所以此時radius 的值爲0；

也就是說，完整的實例化的實際過程應該是：

1，在其他任何事物發生以前，將分配給對象的存儲空間初始化爲二進制的0；

2，如之前所述的那樣，調用基類構造器。（第二個代碼中，）

3，按照聲明的順序調用成員的初始化方法。調用覆蓋後的draw()方法，但是RoundGlyph並未調用，radius 值爲0；

4，調用導出類的構造器主體。