java中多级继承中的构造函数调用顺序[重复]

Question

//: c07:Sandwich.java
// Order of constructor calls.
// package c07;
// import com.bruceeckel.simpletest.*;

import java.util.*;

class Meal {
  Meal() { System.out.println("Meal()"); }
}

class Bread {
  Bread() { System.out.println("Bread()"); }
}

class Cheese {
  Cheese() { System.out.println("Cheese()"); }
}

class Lettuce {
  Lettuce() { System.out.println("Lettuce()"); }
}

class Lunch extends Meal {
  Lunch() { System.out.println("Lunch()"); }
}

class PortableLunch extends Lunch {
  PortableLunch() { System.out.println("PortableLunch()");}
}

public class Sandwich extends PortableLunch {
//  private static Test monitor = new Test();
  private Bread b = new Bread();
  private Cheese c = new Cheese();
  private Lettuce l = new Lettuce();
  public Sandwich() {
    System.out.println("Sandwich()");
  }
  public static void main(String[] args) {
    new Sandwich();
   /*
   monitor.expect(new String[] {
      "Meal()",
      "Lunch()",
      "PortableLunch()",
      "Bread()",
      "Cheese()",
      "Lettuce()",
      "Sandwich()"
    });
    // */
  }
} ///:~

这段代码的输出是

Meal()
Lunch()
PortableLunch()
Bread()
Cheese()
Lettuce()
Sandwich()  

既然类中的字段是按照声明的顺序创建的，为什么不呢

Bread()
Cheese()
Lettuce()

在上面的列表中名列前茅？

另外，它试图在这段代码中做什么？

   monitor.expect(new String[] {
      "Meal()",
      "Lunch()",
      "PortableLunch()",
      "Bread()",
      "Cheese()",
      "Lettuce()",
      "Sandwich()"
    });  

一开始我以为是匿名类，但看起来不像。它是在初始化一个字符串数组吗？为什么它没有字符串变量的名称？请告诉我这里使用的编程结构的名称。

Answer 1

构造函数：

public Sandwich() {
    System.out.println("Sandwich()");
}

被编译器翻译成：

public Sandwich() {
    super();   // Compiler adds it if it is not explicitly added by programmer
    // All the instance variable initialization is moved here by the compiler.
    b = new Bread();
    c = new Cheese();
    l = new Lettuce();

    System.out.println("Sandwich()");
}

因此，构造函数中的第一条语句是超类构造函数的链接。事实上，任何构造函数中的第一条语句都链接到超类构造函数。这就是为什么首先调用超类构造函数PortableLunch，由于编译器添加了super()（还记得吗？），它再次将调用链接到它的超类构造函数。

这种构造函数调用的链接一直到继承层次结构顶部的类，从而在最后调用Object类构造函数。

现在，在每个超类构造函数执行完毕，并且所有超类字段都已初始化之后，直接子类构造函数在super() 调用之后开始执行。最后回到Sandwitch() 构造函数，它现在初始化你的3 字段。

所以，基本上你的字段最后会被初始化，因此它们会在最后打印，就在Sandwitch() 打印之前。

实例创建过程的详细解释请参考JLS - §12.5 - Creation of New Class Instance。

---

关于你的第二部分问题：

monitor.expect(new String[] {
      "Meal()",
      "Lunch()",
      "PortableLunch()",
      "Bread()",
      "Cheese()",
      "Lettuce()",
      "Sandwich()"
    });  

这段代码创建了一个未命名的数组，同时初始化了一些字符串字面量。它类似于创建命名数组的方式：

String[] arr = new String[] { "rohit", "jain" };

Answer 2

您的示例中的对象使用继承，这会导致调用构造函数链。使用继承时，从另一个类 (subtype) 继承的类必须调用它扩展的类的构造函数 (super type)。当存在类型层次结构时，意味着多个类在链中相互扩展，对超级构造函数的调用会传播到链中不从另一个类继承的第一个类（忽略 Object）。

必须在执行子类型的构造函数之前调用子类型的超类构造函数，因为它可能依赖于超类型中的字段或方法。构造函数调用链式调用类型层次结构，一旦每个构造函数初始化，子类型就开始实例化。

一旦类类型层次结构中的超类型构造函数被调用，子类型的字段就会被声明，因为子类型的构造函数也可能需要它们。在声明子类型的字段后，子类型构造函数将执行。

这个顺序是必要的，因为子类型可能依赖于在超类型中建立的字段或方法。

Meal() (Top of Class Hierarchy, not including Object)
Lunch() (Extends Meal)
PortableLunch() (Extends Lunch)
Bread() (Field of lunch declared before constructor call)
Cheese() (Field of lunch declared before constructor call)
Lettuce() (Field of lunch declared before constructor call)
Sandwich() (Extends Portable Lunch)

Here is a really good overview of object creation in Java.

Answer 3

首先调用构造函数，然后根据Java Language Specification 中指定的顺序计算其实例变量。这就是你得到的原因

Bread()
Cheese()
Lettuce()

之后

Meal()
Lunch()
PortableLunch()

关于 String[] 初始化，你认为它不是一个匿名类，它只是一个 String 对象的创建，它不一定要分配给一个变量。

Answer 4

new String[] {
      "Meal()",
      "Lunch()",
      "PortableLunch()",
      "Bread()",
      "Cheese()",
      "Lettuce()",
      "Sandwich()"
    }

\上面是anonymous array declaration。在这种情况下，您无需指定大小。

在初始化实例变量之前，将首先调用所有超类构造函数。 即，

订单--->

  Object(), 
  all your superclass constructors,
  instance variables of this class in that order