瞭解Java中的層次結構

Question

我對繼承和對象創建感到困惑，我想了解下面的示例中完全構造了哪些對象。

class example 
{ 
    public static void main (String[] args) 
    { 
     System.out.println("starting...") ; 

     A localAinMain = new A() ;        // object created 
     B localBinMain = new B() ;        // object created 
     C localCinMain = new C() ;        // object created 

     System.out.println("...finishing") ; 

     return ; 
    } 
} 

class A 
{ 
    // class fields 
    protected static int objectNo =  0 ; 
    private static C staticCinA = new C() ;     // object created 

    // instance fields 
    public final int serialNo = ++objectNo ; 

    public A() { System.out.println("\tA.A[" + serialNo + "] - ctor\n") ; } 

    static  { System.out.println("\tA  - static initializer\n") ; } 
} 

class B extends A 
{ 
    // class fields 
    private static B staticBinB = new B() ;      // object created 

    // instance fields 
    private A instanceAinB = new A() ;       // object created 

    public B() { System.out.println("\tB.B[" + serialNo + "] - ctor\n") ; } 

    static  { System.out.println("\tB  - static initializer\n") ; } 
} 

class C extends B 
{ 
    // class fields 
    private static A staticAinC = new A() ;      // object created 

    // instance fields 
    private B instanceBinC = new B() ;       // object created 

    public C() { System.out.println("\tC.C[" + serialNo + "] - ctor\n") ; } 

    static  { System.out.println("\tC  - static initializer\n") ; } 
} 

當我運行這個程序，我得到下面的輸出

starting... 
    A.A[1] - ctor 

    A.A[2] - ctor 

    B.B[1] - ctor 

    B  - static initializer 

    A.A[3] - ctor 

    C  - static initializer 

    A.A[4] - ctor 

    A.A[5] - ctor 

    B.B[4] - ctor 

    A.A[6] - ctor 

    A.A[7] - ctor 

    B.B[6] - ctor 

    C.C[4] - ctor 

    A  - static initializer 

    A.A[8] - ctor 

    A.A[9] - ctor 

    A.A[10] - ctor 

    B.B[9] - ctor 

    A.A[11] - ctor 

    A.A[12] - ctor 

    B.B[11] - ctor 

    A.A[13] - ctor 

    A.A[14] - ctor 

    B.B[13] - ctor 

    C.C[11] - ctor 

...finishing 

我想知道是否有人能解釋對象的創建順序像CC [11]和AA [11]將是「localCinMain 「，但我不理解爲什麼如此任何幫助表示讚賞

Answer 1

當您調用子類的構造函數時，該構造函數中的第一個調用始終必須是對super的調用。如果您沒有明確地調用超類的構造函數，則會隱式地進行調用。

因爲對super的調用總是發生在其他任何事情之前，所以執行的代碼的順序總是超級的，然後是子類。

給超顯式調用的代碼示例：

public class B extends A { 
    public B() { 
     super(); 
     //Code for constructing B. 
    } 
} 

如果嘗試後一些其他的代碼來調用這個地方，你的編譯器會抱怨，因爲這是非法的。

這是回答您的問題嗎？

Answer 2

在Java中，當實例化類時，系統地調用其超類的默認構造函數。遍歷完整的層次結構（進入Object類）。 這是官方記錄here：

如果子類的構造函數調用其超類的構造函數，或隱或顯，你可能會認爲會有構造方法調用，一個全產業鏈，回的構造一路目的。事實上，情況就是如此。它被稱爲構造函數鏈，並且當需要長時間的類下降時你需要知道它。

Answer 3

每個派生類構造函數在執行自身之前調用基類構造函數。

爲什麼？構造函數的工作是正確初始化對象。 Derived類只能訪問其成員，但會繼承Base類的屬性。調用Base類構造函數可確保該對象構造正確。

在執行過程中調用構造函數的順序如下，
1.將內存分配給定義的變量。
2.具有初始化值的構造函數外的變量（例如int a = 10）被初始化。
3.構造函數被調用。但構造函數中的代碼只有在調用Base類構造函數後纔會被執行（隱式地）。

現在給你一個開始瞭解輸出，

當主程序到達「A localAinMain =新的A（）;」線，這是發生了什麼。
1.必須分配A類對象的內存。
2.'ObjectNo'分配給它的空間，C類的對象被分配給它的空間。
3.接下來發生ObjectNo的初始化，然後發生C類對象的初始化。現在在類C中遵循類似的方法來查看如何分配對象的空間以及如何調用構造函數。請記住，當調用Class C的構造函數時，必須調用A和B的構造函數，因爲類C從它們繼承。

我希望這可以清除你的問題。請隨時糾正答案或進一步提問，因爲我也是一名學習者。