Java对象初始化顺序

初始化 顺序应该是.

父静态变量-->子静态变量-->父非静态变量-->父静态代码块-->父构造函数------>子非变量-->子静态代码块-->子构造函数

以上是网上盛传的

其实应该是这样：（大家自己写代码验证）

1． 父类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行
2． 子类静态成员和静态初始化块 ，按在代码中出现的顺序依次执行
3． 父类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行
4． 父类构造方法
5． 子类实例成员和实例初始化块 ，按在代码中出现的顺序依次执行
6． 子类构造方法
附测试代码：

package test2;

/**
* @author Lansine
*
*/
public class PrintClass {

/**
* @param args
*/
public static void main(String[] args){
new B();
}
PrintClass(String var) {
System.out.println(var);
}
}

package test2;

/**
* @author Lansine
*
*/
class A {
static PrintClass pClassA1 = new PrintClass("A. 静态成员的初始化1");
static {
System.out.println("A. 静态初始化块1");
}
static {
System.out.println("A. 静态初始化块2");
}

static PrintClass pClassA2 = new PrintClass("A. 静态成员的初始化2");
{
System.out.println("A. 实例初始化块1");
}

PrintClass pClassA = new PrintClass("A. 实例成员的初始化");
{
System.out.println("A. 实例初始化块2");
}

public int Avar;

public A() {
System.out.println("A. 构造方法");
doSomething();
}

private void doSomething() {
//public void doSomething() {
Avar = 1111;
System.out.println("Avar=" + Avar);
}
}

package test2;

/**
* @author Lansine
*
*/
public class B extends A {

public static void main(String[] args) {
new B();
}

public int Bvar = 2222;
{
System.out.println("B. 实例初始化块1");
}
{
System.out.println("B. 实例初始化块2");
}

PrintClass pClassB = new PrintClass("B. 实例成员的初始化");
static {
System.out.println("B. 静态初始化块1");
}

static PrintClass pClassB1 = new PrintClass("B. 静态成员的初始化1");

static PrintClass pClassB2 = new PrintClass("B. 静态成员的初始化2");
static {
System.out.println("B. 静态初始化块2");
}

public B() {
System.out.println("B. 构造方法");
doSomething();
}

public void doSomething() {
System.out.println("Bvar=" + Bvar);
}

}

测试结果：

A. 静态成员的初始化1
A. 静态初始化块1
A. 静态初始化块2
A. 静态成员的初始化2
B. 静态初始化块1
B. 静态成员的初始化1
B. 静态成员的初始化2
B. 静态初始化块2
A. 实例初始化块1
A. 实例成员的初始化
A. 实例初始化块2
A. 构造方法
Avar=1111
B. 实例初始化块1
B. 实例初始化块2
B. 实例成员的初始化
B. 构造方法
Bvar=2222