内部类的继承从而实现对父类的private字段的引用

 

子类

public class SubClass extends SuperClass.InnerClass {
	SuperClass superClass;
	public SubClass (SuperClass superClass){
		superClass.super();   //由于内部类构建器必须同封装类对象的一个句柄联系到一起，
                                                     //所以从一个内部类继承的时候这里建立一个句柄
		this.superClass = superClass;
	}
	
	public void show(){
		System.out.println(this.returnPrivates());
	}
}

父类： 有一个private 的字段privates

public class SuperClass {
	private String privates = "know by Super itsself";
	
	public class InnerClass {
				
		public String returnPrivates(){
			return privates;
		}
	}
}

  测试类：

public class Test {
	public static void main(String[] args) {
		SubClass sub = new SubClass (new SuperClass());
		sub.show();
	}

}

 

 

--------如何实现继承内部类 （转） http://hi.baidu.com/huhoo99/item/6308b1c40d95f97789ad9eb1 --------------------------------------------------

 

从内部类继承
由于内部类构建器必须同封装类对象的一个句柄联系到一起，所以从一个内部类继承的时候，情况会稍微变得有些复杂。这儿的问题是封装类的“秘密”句柄必须获得初始化，而且在衍生类中不再有一个默认的对象可以连接。解决这个问题的办法是采用一种特殊的语法，明确建立这种关联：

    //: InheritInner.java// Inheriting an inner classclass WithInner {  class Inner {}}public class InheritInner     extends WithInner.Inner {  //! InheritInner() {} // Won't compile   InheritInner(WithInner wi) {     wi.super();   }  public static void main(String[] args) {     WithInner wi = new WithInner();     InheritInner ii = new InheritInner(wi);   }} ///:~


从中可以看到，InheritInner只对内部类进行了扩展，没有扩展外部类。但在需要创建一个构建器的时候，默认对象已经没有意义，我们不能只是传递封装对象的一个句柄。此外，必须在构建器中采用下述语法：
enclosingClassHandle.super();
它提供了必要的句柄，以便程序正确编译。

7.6.7 内部类可以覆盖吗？
若创建一个内部类，然后从封装类继承，并重新定义内部类，那么会出现什么情况呢？也就是说，我们有可能覆盖一个内部类吗？这看起来似乎是一个非常有用的概念，但“覆盖”一个内部类——好象它是外部类的另一个方法——这一概念实际不能做任何事情：

    //: BigEgg.java// An inner class cannot be overriden // like a methodclass 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 classclass 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()的被覆盖版本。