了解Java中的层次结构

我对继承和对象创建感到困惑，我想了解下面的示例中完全构造了哪些对象。了解Java中的层次结构

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 “，但我不理解为什么如此任何帮助表示赞赏

来源

2014-02-16 Infinite_Loop

当您调用子类的构造函数时，该构造函数中的第一个调用始终必须是对super的调用。如果您没有明确地调用超类的构造函数，则会隐式地进行调用。

因为对super的调用总是发生在其他任何事情之前，所以执行的代码的顺序总是超级的，然后是子类。

给超显式调用的代码示例：

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

如果尝试后一些其他的代码来调用这个地方，你的编译器会抱怨，因为这是非法的。

这是回答您的问题吗？

来源

2014-02-16 21:20:52

在Java中，当实例化类时，系统地调用其超类的默认构造函数。遍历完整的层次结构（进入Object类）。这是官方记录here：

如果子类的构造函数调用其超类的构造函数，或隐或显，你可能会认为会有构造方法调用，一个全产业链，回的构造一路目的。事实上，情况就是如此。它被称为构造函数链，并且当需要长时间的类下降时你需要知道它。

来源

2014-02-16 21:22:38

每个派生类构造函数在执行自身之前调用基类构造函数。

为什么？构造函数的工作是正确初始化对象。 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从它们继承。

我希望这可以清除你的问题。请随时纠正答案或进一步提问，因为我也是一名学习者。

来源

2014-02-16 22:32:59

了解Java中的层次结构

回答

相关问题