内部类的继承

1、内部和普通类一样，也是可以被继承，这样给本来就十分灵活的内部类增加了更好的灵活性和代码复用性，只是内部类的继承和普通类有一些不同之处，是在使用时要多加注意的，因为内部类的创建需要外部类的引用

所以在内部类的继承上需要外部类的协助。

public class A {
    class CC{
        
    }
}

public class B extends A.CC{
    B(A a) {
        a.super();
    }
    
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
    
    }
}

首先在继承语句extends处，注意命名空间，需要加上外围类名，才能对应上正确的内部类。其次是构造对象上，这里需要自己写一个接受外围类引用的构造器，来给导出类提供创建对象的基本环境。注意在构造器中的这一句wi.super()这是必须在构造器中使用的，才能够成功的构造出一个继承自内部类的对象。及enclosingClassReference.super()这个语法一定要牢记。

这是简单的默认构造器的继承，下面的示例难一点，题目是：创建一个包含内部类的类，此内部类有一个非默认构造器（需要参数的构造器）。创建另一个也包含内部类的类继承自第一个内部类。可以先自己试着写一下，看看哪里写的时候有问题，然后对照下面的示例有助于理解，与记忆。

public class B{
    
    class BB extends A.CC{
        BB(A a) {
            a.super("hello");
        }
        
    }
    
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        BB bb = b.new BB(a);//创建内部类时需要外部类对象引用，才能成功创建
    }
}

和上面一例没有太大的区别，就是构造器带上了参数，其次是在内部类对象的创建上，需要先有一个外围对象然后用className.new 的语法进行创建，如果不清楚的可以看前面几篇关于内部类的创建的文章，有写。

以上就是内部类的继承了。既然说到了继承，很自然的就会联想到，内部类会被覆盖吗？
到一个外部类继承自另一个含有内部类的父类。然后在该类中重写了父类的内部类，这个时候会怎么样呢？父类的内部类会被覆盖吗？看下面代码，告诉你答案：

public class Egg {
    private Yolk y;
    protected class Yolk{
        public Yolk() {
            System.out.println("Egg.Yolk!");
        }
    }
    
    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();
    }
}

输出结果：
New Egg
Egg .Yolk!

由输出可以看出，重写的内部类并没有被调用，说明了在不同的外围类中的内部类是相互独立的实体，他们存在于自己的命名空间中，如果想要实现覆盖的话，可以直接使用继承语法，将子类的内部类继承自父类的内部类

public class Egg1 {

    protected class Yolk{
        public Yolk() {
            System.out.println("Egg1.Yolk");
        }
        
        public void f() {
            System.out.println("Egg1.Yolk.f()");
        }
    }
    public Egg1() {
        System.out.println("new Egg1()");
    }
    
    private Yolk y = new Yolk();
    public void insertYolk(Yolk yy) {
        y = yy;
    }

    public void g() {
        y.f();
    }
}

public class BigEgg1 extends Egg1{
    public class Yolk extends Egg1.Yolk{
        public Yolk() {
            System.out.println("BigEgg1.Yolk()");
        }
        
        public void f() {
            System.out.println("BigEgg1.Yolk.f()");
        }
    }
    
    public BigEgg1() {
        insertYolk(new Yolk());
    }
    
    public static void main(String[] args) {
        Egg1 e1 = new BigEgg1();
        e1.g();
    }
}

输出结果：

Egg1.Yolk
new Egg1()
Egg1.Yolk
BigEgg1.Yolk()
BigEgg1.Yolk.f()