java学习笔记---理解内部类

（1）内部类的继承

class WithInner
{
class Inner
{
}
}
public class InheritInner extends WithInner.Inner
{
InheritInner(WithInner wi)
{
wi.super();
}
public static void main(String[] args)
{
WithInner wi=new WithInner();
InheritInner ii=new InheritInner(wi);
}
}

可以看到，InheritInner只继承自内部类，而不是外围类。但是当要生成一个构造器时，默认的构造器并不算好，而且不能只是传递一个指向外围类对象的引用。此外，还必须在构造器中使用如下语法：

enclosingClassReference.super();

这样才提供了必要的引用，然后程序才能编译通过。

(2)内部类可以被覆盖吗

如果创建了一个内部类，然后继承其外围类并重新定义此内部类时，会发生什么呢？也就是说，内部类可以被覆盖吗？实际上，内部类就好像是外围类的一个方法，其实并不起作用。

class Egg1
{
private York y;
protected class York
{
public York()
{
System.out.println("Egg.York()");
}
}
public Egg1()
{
System.out.println("New Egg()");
y=new York();
}
}

public class BigEgg extends Egg1
{
public class York
{
public York()
{
System.out.println("BigEgg.York()");
}
}
public static void main(String[] args)
{
new BigEgg();
}
}

结果为：

New Egg()
Egg.York()

默认的构造器是编译器自动生成的，这里是调用基类的默认构造器。该例子说明，当继承了某个外围类的时候，内部类并没有什么特别神奇的变化。这两个内部类时完全独立的两个实体，各自在自己的命名空间内。

当然，明确继承某个内部类也是可以的

class Apple
{
public Apple()
{
System.out.println("Apple()");
}
}
class Egg
{
protected class York
{
public York()
{
System.out.println("Egg.York()");
}
public void f()
{
System.out.println("Egg.York.f()");
}
}
private York y=new York();
private Apple a=new Apple();
public Egg()
{
System.out.println("Egg()");
}
public void insertYork(York yy)
{
y=yy;
}
public void g()
{
y.f();
}
}

public class OverrideInnerClassTest extends Egg
{
private Apple a=new Apple();
public class York extends Egg.York
{
public York()
{
System.out.println("BigEgg.York()");
}
public void f()
{
System.out.println("BigEgg.York.f()");
}
}
public OverrideInnerClassTest()
{
insertYork(new York());
}
public static void main(String[] args)
{
OverrideInnerClassTest bigEgg=new OverrideInnerClassTest();
bigEgg.g();
}
}

结果是：

Egg.York()
Apple()
Egg()
Apple()
Egg.York()
BigEgg.York()
BigEgg.York.f()

此例的另一个目的也是在此熟悉，当存在继承结构时，各个构造方法的调用顺序。