java初始化顺序

首先是不包含继承的情况：

初始化顺序：在类内部，变量定义的先后顺序决定了初始化的顺序。即使变量定义散布于方法定义之间，它们仍旧会在任何方法（包括构造器）被调用之前初始化。

及 先变量--->再方法 ，而变量初始化先初始化静态（static）变量。示例代码：

package constructor;
class Window{
	public Window(int market) {
		System.out.println("Window("+market+")");
	}
}
class House{
	Window w1=new Window(1);
	void l(){System.out.println("l()");}
	public House() {
		System.out.println("House()");
		w3=new Window(33);
	}
	Window w2=new Window(2);
	void f(){ System.out.println("f()");}
	Window w3=new Window(3);
	static Window w4=new Window(4);
}
public class OrderOfInitialization {

	public static void main(String[] args) {
		House h=new House();
		h.f();
		h.l();
	}
	static Window window =new Window(100);
	static Window win2=new Window(200);
}

执行结果如下：

Window(100)
Window(200)
Window(4)
Window(1)
Window(2)
Window(3)
House()
Window(33)
f()
l()

OrderOfInitialization类中先初始化static变量，进入main函数new House类也是新初始化static变量，然后初始化变量，最后调用构造器。

包含继承的情况：

package use_of_final;
class Insect{
private int i=9;
protected int j;
	public Insect() {
			System.out.println("i="+i+",j="+j);
			j=39;
		}
	private static int x1=printInit("static Insect.x1 initialed");
	static int printInit(String s){
		System.out.println(s);
		return 47;
	}
}
public class Beetle extends Insect{
	private  int  k=printInit("Beetl.k initialized");
	public Beetle(){
		System.out.println("k="+k);
		System.out.println("j="+j);
	}
	private static int x2=printInit("static Beetle.x2 initialized");
	
	public static void main(String[] args) {
		System.out.println("Beetle constructor");
		Beetle b=new Beetle();	
	}
}

结果输出：

static Insect.x1 initialed
static Beetle.x2 initialized
Beetle constructor
i=9,j=0
Beetl.k initialized
k=47
j=39

结果分析：首先父类中继承的private static int x1=printInit("static Insect.x1 initialed"); 初始化，然后是子类中private static int x2=printInit("static Beetle.x2 initialized")初始化。Beetle b=new Beetle();先调用父类构造器然后是自己类中构造器。

复杂构造器调用要遵循下面的顺序：

1.调用基类构造器。这个步骤不断重复递归下去，首先是构造这种层次结构的根，然后是下一层导出类，等等直到最底层的导出类。

2.按声明顺序调用成员的初始化方法。

3.调用导出类构造器主体。

package polymorphism;

class Meal{
	public Meal() {
		System.out.println("  Meal() ");
	}
}
class Bread{
	public Bread(){
		System.out.println("  Bread() ");
	}
}
class Cheese{
	public Cheese(){
		System.out.println("  Cheese() ");
	}
}
class Lettuce{
	public Lettuce(){
		System.out.println("  Lettuce() ");
	}
}
class Lunch extends Meal{
	public Lunch(){
		System.out.println("  Lunch() ");
	}
}
class PortableLunch extends Lunch{
	public PortableLunch() {
		System.out.println("  PortableLunch() ");
	}
}
public class Sandwich extends PortableLunch{
	private Bread b=new Bread();
	private Cheese c=new Cheese();
	
	public Sandwich(){
		System.out.println("  Sandwich() ");
	}
	public static void main(String[] args) {
		new Sandwich();
	}
	private static Lettuce l=new Lettuce();
}

执行结果：

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

先初始化Sandwich 类中的static变量，new Sandwich类调用顺序如复杂构造器调用要遵循下面的顺序所说执行。