若创建一个内部类，然后从封装类继承，并重新定义内部类，那么会出现什么情况呢？也就是说，我们有可能覆盖一个内部类吗？这看起来似乎是一个非常有用的概念，但“覆盖”一个内部类――好象它是外部类的另一个方法――这一概念实际不能做任何事情：
　　
　　//: 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()的被覆盖版本。