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()

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