java 构造函数调用顺序 当一个复杂的对象被构造时,它的构造函数按下面的顺序被调用(that the order of constructor calls for a complex object is as follows) 1.其基类(base-class)的构造函数被调用,这个步骤以递归的方式重复,所以最底层(the root of hierarchy)的构造函数首先被执行,然后是它上一层派生类(the next-derived class)...直到最顶层的派生类(the most-derived class).The base-class constructor is called. This step is repeated recursively such that the root of the hierarchy is constructed first, followed by the next-derived class, etc., until the most-derived class is reached.) 2.如果有包含关系(composition),那么它的成员对象按照声明的顺序被构造.Member initializers are called in the order of declaration. 3.派生类构造函数的内容(body)被执行.The body of the derived-class constructor is called. 一个实例: class Cake{ Cake(){System.out.println("Cake()");} }class Meal { Meal() { System.out.println("Meal()"); } }class Bread { Bread() { System.out.println("Bread()"); } }class Cheese { Cheese() { System.out.println("Cheese()"); } }class Lettuce { Lettuce() { System.out.println("Lettuce()"); } }class Lunch extends Meal { Lunch() { System.out.println("Lunch()"); } }class PortableLunch extends Lunch { //if make derived-class object as the menber of the base-class will lead a infinite //loop and program will stop because of the memory consumed
//private Sandwich s=new Sandwich(); private Cake a=new Cake(); PortableLunch() { System.out.println("PortableLunch()");} }public class Sandwich extends PortableLunch { private Bread b = new Bread(); private Cheese c = new Cheese(); private Lettuce l = new Lettuce();
public Sandwich() { System.out.println("Sandwich()"); }
public static void main(String[] args) { new Sandwich(); } } 输出:Meal() Lunch() Cake() PortableLunch() Bread() Cheese() Lettuce() Sandwich() main()函数中要构造一个Sandwich的对象,调用(并不是执行)它基类PortableLunch的构造函数,PortableLunch又递归的调用,然后是Meal,Meal是继承的最底层的基类(不算Object)所以它的构造函数首先被执行,然后按次序返回到Lunch, PortableLunch,但在PortableLunch的构造函数被执行之前,它的成员对象Cake a先按照声明的顺序被构造.然后执行PortableLunch(),接着是Sandwich的成员对象,最后是Sandwich().注:被注释掉的代码,将base-class的对象作为derive-class的成员对象,这样会递归无法结束,最后程序因堆栈耗尽而结束(Exception in thread main java.lang.StackOverflowError).
楼主回去找本java基础书,仔细看看。
这句话只能用在子类构造函数的第一句
今天加班,等着发版本,好无聊
貌似要了解这个问题还轮不到需要看《Thinking in Java》吧
java 构造函数调用顺序
当一个复杂的对象被构造时,它的构造函数按下面的顺序被调用(that the order of constructor calls for a complex object is as follows)
1.其基类(base-class)的构造函数被调用,这个步骤以递归的方式重复,所以最底层(the root of hierarchy)的构造函数首先被执行,然后是它上一层派生类(the next-derived class)...直到最顶层的派生类(the most-derived class).The base-class constructor is called. This step is repeated recursively such that the root of the hierarchy is constructed first, followed by the next-derived class, etc., until the most-derived class is reached.) 2.如果有包含关系(composition),那么它的成员对象按照声明的顺序被构造.Member initializers are called in the order of declaration. 3.派生类构造函数的内容(body)被执行.The body of the derived-class constructor is called. 一个实例:
class Cake{
Cake(){System.out.println("Cake()");}
}class Meal {
Meal() { System.out.println("Meal()"); }
}class Bread {
Bread() { System.out.println("Bread()"); }
}class Cheese {
Cheese() { System.out.println("Cheese()"); }
}class Lettuce {
Lettuce() { System.out.println("Lettuce()"); }
}class Lunch extends Meal {
Lunch() { System.out.println("Lunch()"); }
}class PortableLunch extends Lunch {
//if make derived-class object as the menber of the base-class will lead a infinite
//loop and program will stop because of the memory consumed
//private Sandwich s=new Sandwich();
private Cake a=new Cake();
PortableLunch() { System.out.println("PortableLunch()");}
}public class Sandwich extends PortableLunch
{
private Bread b = new Bread();
private Cheese c = new Cheese();
private Lettuce l = new Lettuce();
public Sandwich() {
System.out.println("Sandwich()");
}
public static void main(String[] args) {
new Sandwich();
}
}
输出:Meal()
Lunch()
Cake()
PortableLunch()
Bread()
Cheese()
Lettuce()
Sandwich() main()函数中要构造一个Sandwich的对象,调用(并不是执行)它基类PortableLunch的构造函数,PortableLunch又递归的调用,然后是Meal,Meal是继承的最底层的基类(不算Object)所以它的构造函数首先被执行,然后按次序返回到Lunch, PortableLunch,但在PortableLunch的构造函数被执行之前,它的成员对象Cake a先按照声明的顺序被构造.然后执行PortableLunch(),接着是Sandwich的成员对象,最后是Sandwich().注:被注释掉的代码,将base-class的对象作为derive-class的成员对象,这样会递归无法结束,最后程序因堆栈耗尽而结束(Exception in thread main java.lang.StackOverflowError).