package inheritance;

public class InitializeClassObject {

	public static void main(String[] args) {
		System.out.println("初始化第一個C類物件");
		new C();
		
		System.out.println("\n初始化第二個C類物件");
		new C();
	}
	
	static class MyLog{
		public MyLog(String mes){
			System.out.println(mes);
		}
	}
	static class A{
		public A() {
			System.out.println("new A () 定義在最前面");
		}
		
		{
			System.out.println("A {} 1");
		}
		static {
			System.out.println("A static {} 1");
		}
		
		MyLog varA = new MyLog("varA");
		public static MyLog staA = new MyLog("staA"); 
		
		static {
			System.out.println("A static {} 2");
		}
		{
			System.out.println("A {} 2");
		}
	}

	static class B extends A{
		{
			System.out.println("B {} 1");
		}
		static {
			System.out.println("B static {} 1");
		}
		
		public B() {
			System.out.println("new B () 定義在中間");
		}
		
		MyLog varB = new MyLog("varB");
		public static MyLog staB = new MyLog("staB"); 
		
		static {
			System.out.println("B static {} 2");
		}
		{
			System.out.println("B {} 2");
		}
	}

	static class C extends B{
		{
			System.out.println("C {} 1");
		}
		static {
			System.out.println("C static {} 1");
		}
		
		MyLog varC = new MyLog("varC");
		public static MyLog staC = new MyLog("staC"); 
		
		public C() {
			System.out.println("new C () 定義在中間稍後的位置");
		}
		static {
			System.out.println("C static {} 2");
		}
		{
			System.out.println("C {} 2");
		}
	}

}

 

輸出結果:

初始化第一個C類物件
A static {} 1
staA
A static {} 2
B static {} 1
staB
B static {} 2
C static {} 1
staC
C static {} 2
A {} 1
varA
A {} 2
new A () 定義在最前面
B {} 1
varB
B {} 2
new B () 定義在中間
C {} 1
varC
C {} 2
new C () 定義在中間稍後的位置

初始化第二個C類物件
A {} 1
varA
A {} 2
new A () 定義在最前面
B {} 1
varB
B {} 2
new B () 定義在中間
C {} 1
varC
C {} 2
new C () 定義在中間稍後的位置
 

結論:

繼承鏈上的所有類均第一次載入的時候1.按照定義的順序, 執行祖先類的靜態成員變數的賦值語句和靜態初始化塊(兩者同一優先順序)......2.按照定義的順序, 執行父類的靜態成員變數的賦值語句和靜態初始化塊(兩者同一優先順序)3.同樣處理當前類4.類的載入已經完成5.按照定義的順序,執行祖先類的普通成員變數的賦值語句和初始化塊(兩者同一優先順序)，再執行祖先類的構造方法(優先順序比前兩個低)......6.同樣處理父類7.同樣處理當前類另外, 類初始化完成後，將會一直存在在虛擬機器中，再次執行時無須進行類初始化, 也就省略了1-4步