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方法之前）→子类创建对象后→
父类的非静态变量初始化→父类的构造方法初始化→子类的非静态变量初始化→子类的构造方法初始化。
静态初始化与非静态初始化顺序：按照语句顺序逐一进行