那位大侠能够告诉一下这段代码的执行机制

Question

这段代码的执行结果看的不太懂，谁能帮忙解释一下呢？？
class Bowl {
Bowl(int marker) {
System.out.println("Bowl(" + marker + ")");
}

void f(int marker) {
System.out.println("f(" + marker + ")");
}
}

class Table {
static Bowl b1 = new Bowl(1);

Table() {
System.out.println("Table()");
b2.f(1);
}

void f2(int marker) {
System.out.println("f2(" + marker + ")");
}

static Bowl b2 = new Bowl(2);
}

class Cupboard {
Bowl b3 = new Bowl(3);

static Bowl b4 = new Bowl(4);

Cupboard() {
System.out.println("Cupboard()");
b4.f(2);
}

void f3(int marker) {
System.out.println("f3(" + marker + ")");
}

static Bowl b5 = new Bowl(5);
}

public class StaticInitialization {
public static void main(String[] args) {
System.out.println("Creating new Cupboard() in main");
new Cupboard();
System.out.println("Creating new Cupboard() in main");
new Cupboard();
t2.f2(1);
t3.f3(1);
}

static Table t2 = new Table();

static Cupboard t3 = new Cupboard();
}

Answer 1

你这个题写的太重复了，其实道理都一样，主要就是在初始化一个类时，该类静态属性变量初始化会最先执行（静态变量被初始化一次后，以后不会再被重复执行），其次是普通属性，然后是类的构造函数，最后才是方法调用。知道了这个顺序，结果就很好分析了，我们来一步一步分析代码：
1、StaticInitialization 类会最先被调用，因为它有static void main方法，是程序执行的入口。所以这个类就会最先初始化，按上面说的顺序，此类的静态属性变量初始化会最先被执行。因此按代码顺序“static Table t2 = new Table();”会最先执行，其次是“static Cupboard t3 = new Cupboard();”，最后才是 static void main方法。

2、“static Table t2 = new Table();”执行时会初始化Table类，Table类初始化时又会最先初始化此类的静态属性变量“static Bowl b1 = new Bowl(1);”，其次是“static Bowl b2 = new Bowl(2);”，然后是构造函数。

3、“static Bowl b1 = new Bowl(1);”执行时会初始化Bowl类，Bowl类初始化时又会最先初始化此类的静态属性变量，此类没有静态属性变量，所以会执行构造函数Bowl(int marker) ，执行结果是在控制台打印出：
Bowl(1)

4、接着是执行“static Bowl b2 = new Bowl(2);”，执行时也会初始化Bowl类，执行构造函数Bowl(int marker) ，执行结果是在控制台打印出：
Bowl(2)

5、接着会继续执行第2步中的Table类构造函数，执行结果是在控制台打印出：
Table()
f(1)

6、然后依此类推，继续执行第一步的“static Cupboard t3 = new Cupboard();”

7、“static Cupboard t3 = new Cupboard();”执行时会初始化Cupboard类，Cupboard类初始化时又会最先初始化此类的静态属性变量“static Bowl b4 = new Bowl(4);”，其次是“static Bowl b5 = new Bowl(5);”，然后是普通的属性初始“Bowl b3 = new Bowl(3);”，最后是执行构造函数。
这一步的执行结果就是在控制台输出：
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)

8、到这里才会执行static void main方法，按代码顺序分别执行：
System.out.println("Creating new Cupboard() in main");
new Cupboard();
System.out.println("Creating new Cupboard() in main");
new Cupboard();
t2.f2(1);
t3.f3(1);
以上除了执行new Cupboard();时要按上面说的类初始化执行顺序执行,这里要注意静态变量以前已经被初始化后，就不会再被初始化了。其它就都很简单了！
最终输出结果是：
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
f2(1)
f3(1)

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
全部的执行结果如下：
Bowl(1)
Bowl(2)
Table()
f(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f(2)
f2(1)
f3(1)

Answer 2

什么机制不机制的，就是运行先后顺序呗。。。自己debug一下不就清楚了。

Answer 3

你这个程序不就是Thinking in Java里面的例子么..

理解了初始化顺序就明白了..

初始化顺序我总结的3条原则..

1.静态先于普通..(静态与静态之间或者普通与普通之间的顺序是按代码书写顺序从上到下..静态包括静态属性和静态初始化块..就是..
static {
代码
}
这种..普通也同样包括普通属性和普通初始化块..就是..
{
代码
}
这种
)

2.父类先于子类..(所以你new任何类都是先初始化Object里面的东西..只是你没感觉到而已)

3.最后才是构造方法..(你new一个类的时候..先初始化类里面的东西..最后再执行构造方法..)

所以就很好理解了..程序运行时..首先初始化主方法所在类的父类的静态属性和静态初始化块(当然你这他的父类是Object..没有什么静态东西可以初始化的)..然后他自己子类的静态属性..为什么要先初始化静态的..因为静态的可以不用对象调用..即你可以在main方法里面直接调用..如果没初始化你怎么调用呢..所以在你的程序代码执行之前Java虚拟机先初始化了那些静态的东西..
普通属性只有在你new那个类的时候才会执行..
明白了我总结的那几点我想你就明白初始化顺序了..