java初始化分析

class Egg2 {

static int i=5;
int j=5;
static//父類靜態變量初始化塊首先被執行，在main方法之前。
{
System.out.println("superClass static block initialized ");
}
protected class Yolk {
public Yolk() {
System.out.println("Egg2.Yolk()");
}
public void f() {
System.out.println("call method f() in superClass");

}
private void m() {
System.out.println("call method m() in superClass");
}

}

private Yolk y = new Yolk();//y是Yolk的對象同時是Egg2的成員
{ //非靜態變量語句塊，在靜態語句塊之后，main方法之后，構造方法之前執行
System.out.println("superClass member block initialized");
}
public Egg2() {
System.out.println("New Egg2()");//2
System.out.println("Egg2`s constructor initialized");

}
public void insertYolk(Yolk yy) {
y = yy;
}
public void g() {
y.f();
y.m();

}
private void n() {
System.out.println("method n() in superClass");
}
}
public class BigEgg2 extends Egg2 {
static int i;
int j=10;
static //子類靜態初始化塊在父類靜態初始化塊后執行，在main方法之前。
{
System.out.println("subClass static block initialized");
}
{ //子類的非靜態初始化塊
Yolk subY =new Yolk();
System.out.println("subClass member block initialized");
}
public class Yolk extends Egg2.Yolk {
public Yolk() {
System.out.println("BigEgg2.Yolk()");
}
public void f() {
System.out.println("invoke method f() in subClass");
}
public void m() {
System.out.println("invoke method m() in subClass");
}
}
public BigEgg2() {
System.out.println("begin new Yolk() in BigEgg2`s constructor");
insertYolk(new Yolk());

}
public void n() {
System.out.println("method n() in subClass");
}
public static void main(String[] args) {
System.out.println("main begins!");
System.out.println("-------------------------------");
Egg2 e2 = new BigEgg2();
e2.g();
//e2.n(); error! 因為父類的n方法是private的，所以無法在此訪問
System.out.println("e2.i= "+e2.i);
System.out.println("e2.j= "+e2.j);
System.out.println("-------------------------------");
BigEgg2 ee=new BigEgg2();
ee.g();
ee.n();
System.out.println("ee.i= "+ee.i);
System.out.println("ee.j= "+ee.j);
System.out.println("i = "+i);
}
}
/* The Result:
superClass static block initialized
subClass static block initialized
main begins!
-------------------------------
Egg2.Yolk() 由于private Yolk y = new Yolk();創建Yolk的對象，調用
Yolk的構造方法，因此此句被輸出來。
superClass member block initialized 在父類構造方法之前初始化
New Egg2()在非靜態變量初始化完畢后
Egg2`s constructor initialized 構造方法開始初始化
Egg2.Yolk()經過了靜態初始化，父類非靜態變量初始化，父類構造方法初始化后，子類終于開始了自己的初始化,首先先做非靜態變量初始化吧。
BigEgg2.Yolk()因為Yolk subY =new Yolk();所以先調用父類的構造方法，在
subClass member block initialized子類的構造方法，以上2句被輸出
begin new Yolk() in BigEgg2`s constructor開始子類的構造方法初始化
Egg2.Yolk()因為insertYolk(new Yolk());又再次new Yolk()所以再次輸出
BigEgg2.Yolk()內部類同樣是外部類的成員，如同方法一樣，因為子類的內部類與父類的內部類同名，所以發生override關系。先調用父類的構造，再子類的構造。
invoke method f() in subClass因為是在父類的方法中調用f方法，所以JVM會先檢查父類中的f()方法，再調用時，卻因為子類override了父類的f方法，所以會調用子類的f方法而不會調用父類的f方法。
call method m() in superClass因為父類的m方法是private的所以直接調用父類的，而不會調用子類的。
e2.i=5 因為e2是通過Egg2 e2 = new BigEgg2();創建的，屬于Egg2的引用，
BigEgg2的對象，因此它會首先在Egg2中尋找調用的方法或變量，再加以賦值，或調用方法
而如果子類的方法override了父類的方法，則會去調用子類的方法，但是變量去只使用父類的而不會使用子類的，因為變量不能override吧。此時如果父類沒有i這個變量，則編譯報錯.cannot resolve symbol
e2.j=5
-------------------------------
Egg2.Yolk()
superClass member block initialized
New Egg2()
Egg2`s constructor initialized
Egg2.Yolk()
BigEgg2.Yolk()
subClass member block initialized
begin new Yolk() in BigEgg2`s constructor
Egg2.Yolk()
BigEgg2.Yolk()
invoke method f() in subClass
call method m() in superClass
method n() in subClass
ee.i=0 由于ee是通過BigEgg2 ee=new BigEgg2()創建的，所以運行時不會去先去尋找父類的變量和方法。直接調用子類的。
ee.j=10
i=0*/
初始化順序：父類靜態初始化→子類靜態初始化（在main方法之前）→子類創建對象后→
父類的非靜態變量初始化→父類的構造方法初始化→子類的非靜態變量初始化→子類的構造方法初始化。
靜態初始化與非靜態初始化順序：按照語句順序逐一進行