Java 实例内部类的学习

package com.easyway.commons.ispace.dev.oop.innerclasses;

/**
 * 实例内部类的学习：
 *  外部类实例与内部类的实例的之间为一对多关系。一个内部类实例只会引用一个外部类实例。
 *  而一个外部类实例对应零个或者多个内部类的实例。在外部类中不能直接访问内部类成员，
 *  必须通过内部类的实例访问。
 * @author Administrator
 * @date 2010-5-11
 * @version 1.0
 * @since JDK6.0
 */
public class JavaClassType {
	
	private int a1;
	public int a2;
	static int a3;
	int v=1;
	
	static int  bs=9;
	
	
	public JavaClassType(int a1,int a2 )
	{
		this.a1=a1;
		this.a2=a2;
	}
	
	protected  int methodA(){
		System.out.println("A:methodA");
		 return a1*a2;
	}
	/**
	 *  （4）一般的内部类（非static类）的内部没有静态属性。在实例内部类中不能定
	 *  义静态成员，而只能定义实例成员。
	 * @author longgangbai
	 * @date 2010-5-10
	 * @version 1.0
	 * @since JDK6.0
	 */
	class B{
	  public	int b1=a1;
	  
	  //  public static int b=9;   编译错误
	  
		int b2=a2;
		int b3=a3;
		int v=2;
		
		/**
		 * (2) 实例内部类的实例自动持有外部类的实例的引用。
		 * 在内部类中，可以直接访问外部类的所有成员。包括成员变狼和成员方法。
		 */
		int b4=new JavaClassType(3,5).a1;  
		
		int b5=methodA();
		/**
		 * (5) 在内部类中不同的地方this的含义不同 
		 */
		private   void methodB(){
			System.out.println("B:methodB");
			System.out.println("v="+v);
			System.out.println("this.v="+this.v);
			System.out.println("A.this.v="+JavaClassType.this.v);
		}
		/**
		 * 在多层嵌套中，内部类可以访问所有外部类的成员。内层内部类可以访问外层内部类。
		 * @date 2010-5-11
		 * @version 1.0
		 * @since JDK6.0
		 */
		class C{
			public	int b1=a1;
			public void methodC(){
				System.out.println("C:methodC");
				methodA();
				methodB();
			} 
		 }
		
		
		/**
		 * 
		 * 局部内部类（在一个方法中定义的内部类，他的可见范围是当前的方法，局部内部类不能访问修饰符及修饰）：
		 * （1）局部内部类和实例内部类一样，可以访问外部类的所有成员
		 * 此外，局部内部类还可以访问所在方法中的final类型的参数和变量。
		 * （2）在局部内部类和实例内部类一样，不能包含静态成员
		 */
		public void methodBC(){
			 final int abc=0;
			  int def=8;
			  class G{
				  
			     // public static int a=9;  局部内部类和实例内部类一样，不能包含静态成员
				  
				 public   int g0=1;
				 protected  int g1=b1;
				 
				 private M m=new M();
				 //  static int g5; 编译错误 
				 
				  private int g2=a1;
				  int g3=abc;
			      // int g4=def; 编译错误
			      
				  
				  class M{
					  private int m0=0;
					  protected int m1=1;
					  public int m2=4;
				  }
			  }
			  G g=new G();
			  //注意下面的代码访问的私有变量
			  int qq= g.g2;
			  System.out.println("g.m.m0 ="+g.m.m0);
		}
		
		/**
		 * 内部类的继承：内部类的子类（F）的构造中必须创建继承内部类（C）的父类（B）的实例：
		 * 
		 * @author longgangbai
		 * @date 2010-5-10
		 * @version 1.0
		 * @since JDK6.0
		 */
		 class F extends B.C{
			 
			 public F(B b){
				 b.super();
			 }
		 }
		
	}
	
	
	
	
	public static class D{
		int d1=bs;
		int d2=new JavaClassType(7,8).a1;
		
		
		public void methodD(){
			System.out.println("d2="+d2);
		}
		
		public static class E{
			 static int e1=3;
		}
		
	}
	
	public static void main(String[] args) {
		JavaClassType.B b=new JavaClassType(1,2).new B();
		System.out.println("b.b1="+b.b1);
		System.out.println("b.b2="+b.b2);
		System.out.println("b.b3="+b.b3);
		
		//System.out.println("b.b4="+b.b4);
		
		System.out.println("b.b5="+b.b5);
		
		JavaClassType jcy=new JavaClassType(1,2);
		
		JavaClassType.B bb=new JavaClassType(3,6).new B();
		//在直接实例内部类的实例的时候，java虚拟机自动使内部类shilling引用它的外部类的实例。
		
		bb.methodB();
		bb.methodBC();
		
		B.C c=b.new C();
		c.methodC();
		
		D d=new D();
		d.methodD();
		
	}

}

 

 

 

 

package com;

/**
 * 那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？
 * 是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？
 * 实际上这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为
 * 例来进行说明。 运行上面的代码，会得到如下的结果：
 * 
 * 1、Test--A 
 * 2、静态初始化块 
 * 3、Test--B
 * 
 * 大家可以随意改变变量a、变量b以及静态初始化块的前后位置，就会发现输出结果随着
 * 它们在类中出现的前后顺序而改变，
 * 这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样，
 * 变量和初始化块也遵循这个规律。
 * 
 * 
 * 
 * @author Administrator
 * 
 */
public class TestOrder {
	// 静态变量
	public static TestA a = new TestA();

	// 静态初始化块
	static {
		System.out.println("静态初始化块");
	}

	// 静态变量
	public static TestB b = new TestB();

	public static void main(String[] args) {
		new TestOrder();
	}
}

class TestA {
	public TestA() {
		System.out.println("Test--A");
	}
}

class TestB {
	public TestB() {
		System.out.println("Test--B");
	}
}