【22】java初始化（静态变量）
先上例子：
1 public class Bowl {
2
3 public Bowl(int marker){
4 System.err.println("Bowl:" + marker);
5 }
6
7 public void BowlFun(int marker){
8 System.err.println("BowlFun(" + marker + ")");
9 }
10 }
public class Table {
public static Bowl b1 = new Bowl(1);
public Table() {
System.err.println("Table()");
b2.BowlFun(1);
}
public void TableFun(int marker) {
System.err.println("TableFun(" + marker + ")");
}
public static Bowl b2 = new Bowl(2);
}
1 public class Cupboard {
2
3 Bowl b3 = new Bowl(3);
4 static Bowl b4 = new Bowl(4);
5
6 public Cupboard() {
7 System.err.println("Cupboard()");
8 b4.BowlFun(2);
9 }
10
11 public void CupboardFun(int marker) {
12 System.err.println("CupboardFun(" + marker + ")");
13 }
14
15 static Bowl b5 = new Bowl(5);
16 }
1 public class RoadBoot {
2
3 public static void main(String args[]){
4
5 System.err.println("Create new Cupboard in main()");
6
7 Cupboard cc = new Cupboard();
8
9 System.err.println("Create new Cupboard in main()");
10
11 cc = new Cupboard();
12
13 table.TableFun(1);
14 cboard.CupboardFun(1);
15 }
16
17 static Table table = new Table();
18 static Cupboard cboard = new Cupboard();
19 }
输出结果是：
Bowl:1
Bowl:2
Table()
BowlFun(1)
Bowl:4
Bowl:5
Bowl:3
Cupboard()
BowlFun(2)
Create new Cupboard in main()
Bowl:3
Cupboard()
BowlFun(2)
Create new Cupboard in main()
Bowl:3
Cupboard()
BowlFun(2)
TableFun(1)
CupboardFun(1)
说明：
1：static成员的初始化只有在需要的时候才会进行（创建包含static成员的类对象，或直接通过类名称引用它内部的static成员）。
2：初始化的顺序是先static对象，再非static对象。
首先看类RoadBoot，包含两个static对象，这两个对象会在main调用之前就被初始化，按顺序来，先初始化table，再初始化cboard。
Table类的内容如下：
1 public class Table {
2
3 public static Bowl b1 = new Bowl(1);
4
5 public Table() {
6 System.err.println("Table()");
7 b2.BowlFun(1);
8 }
9
10 public void TableFun(int marker) {
11 System.err.println("TableFun(" + marker + ")");
12 }
13
14 public static Bowl b2 = new Bowl(2);
15 }
在调用其构造函数之前，会先对其包含的成员变量进行初始化，首先进行static的初始化，按顺序来，b1，会打印出Bowl1；接下来是b2，会打印出Bowl2。
除此之外，该类不包含非static成员，所以要进行构造函数的调用了，则会先打印出Table()，再调用b2.BowlFun(1)打印出BowlFun(1)，Table类完成。
接下来看Cupboard类：
1 public class Cupboard {
2
3 Bowl b3 = new Bowl(3);
4 static Bowl b4 = new Bowl(4);
5
6 public Cupboard() {
7 System.err.println("Cupboard()");
8 b4.BowlFun(2);
9 }
10
11 public void CupboardFun(int marker) {
12 System.err.println("CupboardFun(" + marker + ")");
13 }
14
15 static Bowl b5 = new Bowl(5);
16 }
先进行static成员的初始化b4，会打印出Bowl4，接下来是b5，会打印出Bowl5，没有其它static成员了，再进行非static成员的初始化，b3，打印出
Bowl3，初始化完这个之后，也没有其它的非static成员了，可以进行构造函数的调用了，打印出Cupboard()和BowlFun2
此时，可以进行main函数的调用了：
1 public static void main(String args[]){
2
3 System.err.println("Create new Cupboard in main()");
4
5 Cupboard cc = new Cupboard();
6
7 System.err.println("Create new Cupboard in main()");
8
9 cc = new Cupboard();
10
11 table.TableFun(1);
12 cboard.CupboardFun(1);
13 }
先打印出Create new Cupboard in main()，接着创建Cupboard对象，在该类中，由于静态成员b4和b5已初始化，故不会重复初始化，而只有非static成员b3，
会再次被初始化，打印出Bowl3，接来进再调用构造函数，从而打印出Cupboard()，BowlFun(2)；第7，9行的输出与第3，5行的输出完全相同。
最后，分别执行table.TableFun(1);cboard.CupboardFun(1);打印出TableFun(1)，CupboardFun(1)
再次重申：
1：static成员的初始化只有在需要的时候才会进行（创建包含static成员的类对象，或直接通过类名称引用它内部的static成员）。
2：初始化的顺序是先static对象，再非static对象。
