Java构造函数的调用顺序(Order of constructor calls)

    当一个复杂的对象被构造时,它的构造函数按下面的顺序被调用(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).