阿里的变态题，关于java对象初始化顺序，颠覆了。
public class TestConstructOrder {
public static int k = 0;
public static int k1;
public int k2;
public static TestConstructOrder t1 = new TestConstructOrder("t1");
public static TestConstructOrder t2 = new TestConstructOrder("t2");
public static int i = print("i");
public static int n = 99;
public int j = print("j");
{
print("构造块");
}
static {
print("静态块");
}
public TestConstructOrder(String str) {
System.out.println((++k) + ":" + str + "i=" + i + "n=" + n);
++i;
++n;
}
public static int print(String str) {
System.out.println((++k) + ":" + str + "i=" + i + "n=" + n);
++n;
return ++i;
}
/**
*
*/
public static void main(String[] args) {
TestConstructOrder t = new TestConstructOrder("init");
}
}
// 将会引起Sub的初始化
}
}
class Super{
static int x = 2006;
}
class Sub extends Super {
static final int y = 2005;
static int z;
static {
System.out.println("Initialization Sub");
}
}
2。对象的创建（creation of new class instances），稍微有点烦琐，具体的步骤如下
(a) 所有的成员变量—包括该类，及它的父类中的成员变量--被分配内存空间，并赋予默认值。（Btw，这里是第一次初始化成员变量）
(b) 为所调用的构造函数初始化其参数变量。（如果有参数）
(c) 如果在构造函数中用this 调用了同类中的其他构造函数，则按照步骤(b)~(f)去处理被调用到的构造函数。
(d) 如果在构造函数中用super调用了其父类的构造函数，则按照步骤(b)~(f)去处理被调用到的父类构造函数。
(e) 按照书写顺序，执行instance initializer 和 instance variable initializer来初始化成员变量。（Btw，这里是第二次初始化成员变量）
(f) 按照书写顺序，执行constructor的其余部分。
*注意*
成员变量其实都被初始化2次，第一次是赋予默认值，第二次才是你想要设定的值。
最后看一个例子：
public class InitializationOrder {
public static void main(String[] args) {
Subclass sb = new Subclass();
}
}
class Super{
static {
System.out.println(1);
}
Super(int i){
System.out.println(i);
}
}
class Subclass extends Super implements Interface{
static {
System.out.println(2);
}
Super su = new Super(4);
Subclass() {
super(3);
new Super(5);
}
}
interface Interface{
static Super su = new Super(0);
}
稍微解释一下：
首先，Java虚拟机要执行InitializationOrder类中的static 方法main()，这引起了类的初始化。开始初始化InitializationOrder类。具体的步骤略去不说。
接着，InitializationOrder类初始化完毕后，开始执行main()方法。语句Subclass sb = new Subclass()将创建一个Subclass对象。加载类Subclass后对其进行类初始化，但因为Subclass有一个父类Super，所以先初始化Super类，初始化块static {System.out.println(1);}被执行，打印输出1；
第三，Super初始化完毕后，开始初始化Subclass类。static {System.out.println(2);}被执行，打印输出2；
第四，至此，类的加载工作全部完成。开始进入创建Subclass的对象过程。先为Subclass类和其父类Super类分配内存空间，这时Super su 被附值为null;
第五，执行构造函数Subclass()时，super(3)被执行。如前面(d)所说，Super类的构造函数Super(int i){….}被调用，并按照步骤(b)~(f)来处理。因此，递归调用Super类的父类Object类的构造函数，并按照步骤(b)~(f)来初始化Object类，不过没有任何输入结果。最后打印输出3；
第六，如前面(e)所说，初始化成员变量su，其结果是打印输出4；
第七，如前面(f)所说，执行new Super(5)，并打印输出5；
最后，Subclass虽然实现了接口Interface，但是初始化它的时候并不会引起接口的初始化，所以接口Interface中的static Super su = new Super(0)自始至终都没有被执行到。
① 类属性 (静态变量) 定义时的初始化，如上例的 static String a = "string-a";
② static 块中的初始化代码，如上例 static {} 中的 b = "string-b";
③ 对象属性 (非静态变量) 定义时的初始化，如上例的 String c = "stirng-c";
④ 构造方法 (函数) 中的初始化代码，如上例构造方法中的 d = "string-d";
[解决办法]
http://bbs.csdn.net/topics/390597457
[解决办法]
整个的执行步骤：（下面的分析不包括父类内容）
加载类信息：
1、静态变量默认初始化
2、对静态变量赋值 （赋值顺序按书写顺序）
3、静态代码块中内容
创建对象：
1、实例变量初始化
2、实例变量赋值（依然按顺序）
3、构造代码块中内容
4、构造函数中内容
public static int k = 0; //对静态变量k初始化
public static Test t1 = new Test("t1"); //t1默认值null,下面就是赋值
public Test(String str)//创建t1对象，但现在并不是执行构造函数内的代码
public int j = print("j");//对实例变量赋值，当然赋值前会进行默认初始化，即为0
public static int print(String str) //j变量的输出 执行print代码段 输出
1:j i=0 n=0//此时i和j还没有加载，值仍是默认的值
print("构造快"); //实例变量初始化后，执行构造代码块中内容，对于构造代码块中的内容，每创建一次对象，都会执行一次
public static int print(String str) //构造代码块的输出 执行print
2:构造块 i=1 n=1
public Test(String str)//执行构造函数中代码段，输出
3:t1 i=2 n=2
public static Test t2 = new Test("t2"); //其执行顺序和t1的初始化一样 下面只写输出内容
4:j i=3 n=3
5:构造块 i=4 n=4
6:t2 i=5 n=5
public static int i = print("i"); //继续按顺序对静态变量赋值
public static int print(String str) //输出
7:i i=6 n=6
public static int n = 99;
print("静态块"); //对静态变量赋值完后 执行静态代码块
8:静态块 i=7 n=99 //此时已经对n进行了赋值，所以其值为99
new Test("init") //静态信息加载完毕后 就是对象的创建
public int j = print("j"); //每个对象创建后都会对实例变量 默认初始化 赋值 然后执行构造代码块 构造函数
9:j i=8 n=100
print("构造快");
10：构造块 i=9 n=101
public Test(String str)//构造函数
11：init i=10 n=102
