think in java中 7.6.7章中关于内部类覆盖的一些看法

 原文：

若创建一个内部类，然后从封装类继承，并重新定义内部类，那么会出现什么情况呢？也就是说，我们有可
能覆盖一个内部类吗？这看起来似乎是一个非常有用的概念，但“覆盖”一个内部类——好象它是外部类的
另一个方法——这一概念实际不能做任何事情：
//: BigEgg.java
// An inner class cannot be overriden
// like a method
class Egg {
      protected class Yolk {
            public Yolk() {
                  System.out.println("Egg.Yolk()");

            }
      }
      private Yolk y;
      public Egg() {
            System.out.println("New Egg()");
      y = new Yolk();
      }
}

public class BigEgg extends Egg {
      public class Yolk {
            public Yolk() {
                  System.out.println("BigEgg.Yolk()");

            }
      }
      public static void main(String[] args) {
            new BigEgg();
      }
} ///:~
默认构建器是由编译器自动合成的，而且会调用基础类的默认构建器。大家或许会认为由于准备创建一个
BigEgg，所以会使用Yolk 的“被覆盖”版本。但实际情况并非如此。输出如下：
New Egg()
Egg.Yolk()
这个例子简单地揭示出当我们从外部类继承的时候，没有任何额外的内部类继续下去。然而，仍然有可能
“明确”地从内部类继承：
//: BigEgg2.java
// Proper inheritance of an inner class
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 {
      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();
      }
} ///:~

现在，BigEgg2.Yolk 明确地扩展了Egg2.Yolk，而且覆盖了它的方法。方法insertYolk()允许BigEgg2 将它
自己的某个Yolk 对象上溯造型至Egg2 的y 句柄。所以当g()调用y.f()的时候，就会使用f()被覆盖版本。
输出结果如下：
Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk.f()
对Egg2.Yolk()的第二个调用是BigEgg2.Yolk 构建器的基础类构建器调用。调用
g()的时候，可发现使用的是f()的被覆盖版本。

 

本人的看法

其实阅读完think in java 7.6.7中的2段代码以及分析了输出结果以后，本人做了一些小小的测试：

（1）删除掉public BigEgg2() { insertYolk(new Yolk()); }中的insertYolk(new Yolk());

结果类似于函数中的“覆盖”效果并没有出现

输出结果如下：

Egg2.Yolk()
New Egg2()
Egg2.Yolk.f()

 

（2）将public class Yolk extends Egg2.Yolk 改为public class Yolk

结果编译出错：

BigEgg2.java:26: 无法将 Egg2 中的 insertYolk(Egg2.Yolk) 应用于 (BigEgg2.Yolk)
public BigEgg2() { insertYolk(new Yolk()); }

                             ^

由此可知java根本就没有提供内部类“覆盖”这么一种机制，要达到内部类的覆盖的效果必须自己编写方法来实现“覆盖”的效果

该方法中的作者就是使用了：内部类的继承以及insertYolk(new Yolk());方法来实现的

而并非只要用到内部类的继承就会自动实现覆盖。