j02080701.java

经典java教材《java完美经典》一书中源码的完全收集

import java.lang.*;

class j02080701
{	 
	public static void main(String[] para)
  {			
		OutClass obj1 = new OutClass(100,"abcde");
		obj1.showA();		
		//obj1.showVars(); //错误，obj1 实例并不会直接拥有 InnerClass 类的实例		
		obj1.InnerObj.showVars(); // InnerObj 是一个 InnerClass 类的对象
		
		System.out.println("============== pr1 ==============");
		OutClass.InnerClass Inner1 = obj1.new InnerClass("good");	
		//System.out.println("Inner1.str = " + Inner1.str);	  // 错误，private 成员只能在类内存取                  
		Inner1.showVars();   // obj1.a = 100 ==> Inner1.x = 100.0
		     /* 本次执行 showVars()函数，里面存取的是 a 是 obj1.a，
		        但函数内 this 变量引用的是 obj1 的实例，故其内 this.x =Inner1.x = obj1.a */	
		
		System.out.println("============== pr2 ==============");
		OutClass.InnerClass Inner2 = obj1.new InnerClass("fish");		                         
		Inner2.showVars();  // obj1.a = 100 ==> Inner2.x = 100.0
		 /*由于 Inner1 和 Inner2 都是利用 obj1 才构造实例，故其内所存取之 OutClass 的成员，都是 obj1 的成员*/
		 
		System.out.println("============== pr3 ==============");
		OutClass.InnerClass Inner3 = obj1.getNewInner("Live");  // 函数内 this 引用 obj1 的实例，故 Inner3 也存取 obj1 的成员                     
		Inner3.showVars();  // obj1.a = 100 ==> Inner3.x = 100.0		
		
		System.out.println("============== pr4 ==============");       
		OutClass obj2 = new OutClass(999); //其内 InnerObj 成员 = null
		OutClass.InnerClass Inner4 = obj2.new InnerClass("CYH");	// Inner4 所存取之 OutClass 的成员，是 obj2 的实例成员	                         
		Inner4.showVars();   // obj2.a = 999 ==> Inner5.x = 999.0

		System.out.println("============== pr5 ==============");       
		OutClass.InnerClass Inner5 = (new OutClass(111)).new InnerClass("COOL");	// Inner4 所存取之 OutClass 的成员，是新建无名之 OutClass 对象的实例成员	                         
		Inner5.showVars();   // 新对象.a = 111 ==> Inner5.x = 111.0

		System.out.println("============== pr6 ==============");
		OutClass.InnerClass InnerX  = Inner4.getNewSelf();  // Inner4 所存取的是 OutClass 类之 obj2 对象
		        // getNewSelf() 执行时，其内 new InnerClass() 是直接引用用来建 Inner4 的 obj2 对象
		                     // 等于 obj2.new InnerClass()，但在 InnerClass 内的 this 并非 OutClass 的 this，
		                                                         // 在 InnerClass 内不是透过 this 引用 OutClass 对象本身，this 是引用 InnerClass 对象本身，
                                                             // 而是直接就引用用来建立此 InnerClass 类物的 OutClass 对象 ==> 0bj2
   	InnerX.showVars();		// obj2.a = 999 ==> InnerX.a = 999.0                                                    
  }
}

class OutClass
{
	private int a;
	public InnerClass InnerObj;
	
	public OutClass(int a)
	{
		this.a = a;  //this 所引用是 OutClass 类对象本身
		InnerObj = null;
	}
	
	public OutClass(int a,String innerStr)
	{
		this.a = a; //this 所引用是 OutClass 类对象本身
		InnerObj = new InnerClass(innerStr);
	}
	
	public void showA()
	{
		System.out.println("this = " + this);
		System.out.println("a = " + a);  //this.a		
	}
	
	protected class InnerClass
  { //同于用在外围类 OutClass 其它成员的封装修饰字
	  private String str;	  
	  private float x;
	  //于 InnerClass 内 str 自动为 this.str，x 自动为 this.x，但 OutClass 之 a 不是 this.a
	  //public static int myInt = 999; //错误，不能有 static 成员
	  
	  public InnerClass(String str)
	  {
	  	this.str = str;  //this 所引用是 InnerClass 类对象本身
	  }
		
		public void showVars()
		{
			System.out.println("this = " + this);  // this 所引用是 InnerClass 类对象本身
			System.out.println("此 OutClass 对象之 a = " + a);			
			x = a;  // 直接存取 OutClass 类对象之 a ，不能以 this.a 的方式存取
			//x = this.a; //错误 this 所引用是 InnerClass 类对象，没有 a 成员
			System.out.println("此 InnerClass 对象之 x = " + x);
		}
		
		public InnerClass getNewSelf()
		{
			InnerClass mine = new InnerClass(str);
			//可省略「外围类名」  //可不指定透过那个 OutClass 对象来建立，如此会自动使用之前建立此 InnerClass 对象的 OutClass 对象。
			return mine;
		}
  }
  
	public InnerClass getNewInner(String str)
	{
		OutClass.InnerClass obj = this.new InnerClass(str);
		System.out.println("新建 InnerClass 类对象之 str 成员 = " + obj.str); 
		    //InnerClass 在 OutClass 之内，故 InnerClass 之 private 成员可在 OutClass 内存取
		return obj;
	}	
}