Java中的成员初始化顺序--静态代码、实例变量、构造函数（转）

通过new新建一个对象时，涉及到类的装载及对象的实例化两方面。

1、类的装载

 

    1）类装载时，先装载父类，然后到子类。

    2）装载父类后，执行静态动作（初始化静态变量或执行静态代码程序（两者根据代码顺序执行））。

    3）装载子类后，执行静态动作（初始化静态变量或执行静态代码程序（两者根据代码顺序执行））。

 

2、对象的实例化

 

    1）实例化子类时，会（需要）先实例化父类。

    2）实例化父类时，先完成实例变量的初始化，然后调用构造函数完成实例化工作，子类同理。

 

3、概括来说，初始化顺序如下：

 

    父类的静态代码 -->子类的静态代码-->父类的非静态实例变量（或代码块）-->父类的构造方法-->子类的非静态实例变量（或代码块）-->子类的构造方法。

 

4、测试实例

 

abstract class base {
	public int age = getNumber(100);
	static {
		System.out.println("base static block");
	}

	{
		System.out.println("base nonstatic block");
	}
	
	static int sage = getNumber(50);

	base() {
		System.out.println(age);
		System.out.println("base start");
		draw();// 会调用子类覆盖后的方法，这儿是0！？？？？		
		System.out.println("base end");
	}

	static int getNumber(int base) {
		System.out.println("base.getNumber int" + base);
		return base;
	}

	public void draw() {
		System.out.println("base.draw");
	}
}

public class initializeOrder extends base {
	public int age = getNumber(1001);
	private int _radius = getNumber(10);
	static int sage = getNumber(250);
	static {
		System.out.println("subclass static block");
	}
	{
		System.out.println("subclass nonstatic block");
	}

	initializeOrder(int radius) {
		_radius = radius;
		System.out.println(age);
		draw();// 这儿是1000
		System.out.println("initializeOrder initialized");
	}

	public void draw() {
		System.out.println("initializeOrder.draw " + _radius);
	}

	public static void main(String[] args) { 
                System.out.println("start main()");
		new initializeOrder(1000);
	}
}

   

    执行输出如下：

    base static block
    base.getNumber int50
    base.getNumber int250
    subclass static block

    start main()
    base.getNumber int100
    base nonstatic block
    100
    base start
    initializeOrder.draw 0
    base end
    base.getNumber int1001
    base.getNumber int10
    subclass nonstatic block
    1001
    initializeOrder.draw 1000
    initializeOrder initialized