初始化与内部类的问题

Question

看了3天内部类，感觉我开始犯糊涂了，看下下面代码，本来这个code是目的是演示覆盖内部类的，然而这个用法我认为确实很容易理解 ，但是我糊涂了他的整个代码的初始化过程，我可能对继承，内部类概念搞混了看下面代码：import com.bruceeckel.simpletest.*;class Egg2 {
  protected class Yolk {
    public Yolk() { System.out.println("Egg2.Yolk()"); }
    public void f() { System.out.println("Egg2.Yolk.f()");}
  }
  private Yolk y = new Yolk();
  public Egg2() { System.out.println("New Egg2()"); }
  public void insertYolk(Yolk yy) { y = yy; }
  public void g() { y.f(); }
}public class BigEgg2 extends Egg2 {
  private static Test monitor = new Test();
  public class Yolk extends Egg2.Yolk {
    public Yolk() { System.out.println("BigEgg2.Yolk()"); }
    public void f() {
      System.out.println("BigEgg2.Yolk.f()");
    }
  }
  public BigEgg2() { insertYolk(new Yolk()); }
  public static void main(String[] args) {
    Egg2 e2 = new BigEgg2();
    e2.g();
    monitor.expect(new String[] {
      "Egg2.Yolk()",
      "New Egg2()",
      "Egg2.Yolk()",
      "BigEgg2.Yolk()",
      "BigEgg2.Yolk.f()"
    });
  }
} 
这里首先打印出的是 "Egg2.Yolk()",我的初始化思路是 首先产生了一个Y对象 private Yolk y = new Yolk();所以他先调用了基类内部类构造器中 public Yolk() { System.out.println("Egg2.Yolk()"); }第一个    "Egg2.Yolk()",就输出了，之后
Egg2 e2 = new BigEgg2(),e2产生了BigEgg2类的对象并向上转型为基类Egg2,首先先调用基类构造器， public Egg2() { System.out.println("New Egg2()"); }第2个结果输出了"New Egg2()",然后是导出类的构造器初始化但构造器public BigEgg2() { insertYolk(new Yolk()); }却产生了一个内部类的一个对象，然而这个对象的创建首先调用了其基类Yolk 的构造器 public Yolk() { System.out.println("Egg2.Yolk()"); }结果输出打印了第3个值 "Egg2.Yolk()",之后就开始对导出类Yolk的初始化public Yolk() { System.out.println("BigEgg2.Yolk()"); }输出了第四个BigEgg2.Yolk()",由于insertYolk()方法 将BigEgg2() 中Yolk对象向上转型为Y，通过后期动态绑定，调用g(),方法中f实际调用的是public void f() {
      System.out.println("BigEgg2.Yolk.f()");，最后"BigEgg2.Yolk.f()"的结果输出了，我是这样理解的，不知道思路对不对，我现在对继承与基类，外部类与内部类他们之间关系的差异弄混了，请高手指点下！

Answer 1

这个其实和内部类没什么关系吧？
实例化类的时候先实例化参数（Field），然后构造（constructor）。
构造的时候先构造父类，构造父类前先实例化父类的参数。如此循环。有一个问题是如下代码
abstract class A {
 public A() {
   createA();
 }
 
 public abstract A createA();
}class B extends A {
 private A a = null;
 public A createA() {
  this.a = new B();
  return this.a;
 }
}
在createA方面跟踪的时候你会发现B.a的确!=null, 但是在你使用B的其他方法用到B.a的时候发现是null.
最后B.a是null.
因为初始化B.a, 构造B的时候调用了A的构造, 调用了createA方法,实际上是B里面实现的, 给B.a赋值. 然后构造B, 实例化B.a,也就是执行a = null;这句话, 最后B.a变成null.从这里可以看到private A a = null;这句话实际上是分2个阶段执行的. 如果没有如上的写法, 你不会感到任何的问题.

Answer 2

3楼的哥们bradwoo8621() ，感谢你帮我重新复习了一下继承初始化的概念，也许你这句话，才是我真正忽略或者迷惑的地方“实例化类的时候先实例化参数（Field），然后构造（constructor）。”当打印输出第一个结果：  "Egg2.Yolk()",实际上是首先初始化成员变量private Yolk y = new Yolk();  y即是，然而y产生了一个对象引用，他的构造器就被调用了，  public Yolk() { System.out.println("Egg2.Yolk()"); }，所以第一输出的是"Egg2.Yolk()"！和我之前思想(这里首先打印出的是 "Egg2.Yolk()",我的初始化思路是 首先产生了一个Y对象 private Yolk y = new Yolk();所以他先调用了基类内部类构造器中 public Yolk() { System.out.println("Egg2.Yolk()"); }第一个    "Egg2.Yolk()",就输出了)在思想上还是有很大差异的，不知道我这次理解的对不对，请赐教！谢谢