Java构造器链式调用深度解析：this()与super()的工作机制

本文深入探讨java中类的构造器调用机制，特别是`this()`和`super()`关键字的作用。通过一个具体示例，详细解析构造器链式调用的执行顺序，包括显式和隐式`super()`调用的行为，以及它们如何决定父类和子类构造器的激活路径，从而解释为何某些构造器会被执行而另一些则被跳过，帮助开发者掌握java对象初始化的核心原理。

Java构造器与对象初始化

在Java中，当创建一个新对象时，其对应的构造器会被调用以完成对象的初始化工作。一个类的构造器不仅负责初始化该类自身的成员变量，还需要确保其所有父类的部分也得到正确初始化。为了实现这一目标，Java引入了构造器链（Constructor Chaining）的概念，通过this()和super()关键字来管理构造器之间的调用关系。理解构造器链的工作原理，对于掌握Java对象的完整生命周期和避免潜在的初始化问题至关重要。

this() 与 super()：构造器链的核心

this()和super()是Java中用于构造器调用的两个特殊关键字，它们各自承担着不同的职责，但都必须作为构造器内的第一条语句出现。

this() 关键字

this()用于在一个类的内部调用该类的另一个构造器。它的主要目的是避免代码重复，允许一个构造器重用另一个构造器的初始化逻辑。 例如：

public class MyClass {
    private int value;
    private String name;

    public MyClass() {
        this(0, "default"); // 调用另一个构造器
    }

    public MyClass(int value, String name) {
        this.value = value;
        this.name = name;
    }
}

在使用this()时，必须注意它只能出现在构造器的第一行，并且不能与super()同时出现。

super() 关键字

super()用于调用当前对象的直接父类的构造器。这是确保父类部分在子类初始化之前得到正确初始化的关键机制。 例如：

class Parent {
    public Parent(String message) {
        System.out.println("Parent: " + message);
    }
}

class Child extends Parent {
    public Child() {
        super("Hello from Child"); // 调用父类的带参构造器
        System.out.println("Child constructor");
    }
}

与this()类似，super()也必须是构造器的第一条语句，且不能与this()同时出现。

立即学习“Java免费学习笔记（深入）”；

隐式 super() 调用

Java编译器有一个重要的规则：如果一个构造器的第一行既没有显式调用this()也没有显式调用super()，那么编译器会自动在该构造器的第一行插入一个无参的super();调用。这意味着，每个构造器实际上都必须以this()或super()（显式或隐式）开头。

这个隐式调用有一个前提：父类必须有一个可访问的无参构造器。如果父类只定义了带参数的构造器而没有定义无参构造器，并且子类也没有显式调用super(...)，那么编译器将报错，因为无法找到可用的隐式super();。

示例代码分析：揭示调用顺序

为了更深入地理解构造器链的工作机制，我们来分析一个具体的Java代码示例。

原始代码

public class Test {
    public static void main(String[] args) {
        new Circle9();
    }
}

class GeometricObject {
    GeometricObject() {
        System.out.print("A");
    }
    public GeometricObject(String color, boolean filled) {
        System.out.print("B");
    }
}

class Circle9 extends GeometricObject {
    public Circle9() {
        this(1.0);
        System.out.print("C");
    }
    public Circle9(double radius) {
        this(radius, "white", false);
        System.out.print("D");
    }
    public Circle9(double radius, String color, boolean filled) {
        super(color, filled);
        System.out.print("E");
    }
}

代码结构概览

• Test类：程序的入口点，负责创建Circle9对象。
• GeometricObject类：作为父类，定义了两个构造器：一个无参构造器（打印"A"）和一个带参数的构造器（打印"B"）。
• Circle9类：作为子类，继承自GeometricObject。它定义了三个构造器，巧妙地结合使用了this()和super()，展示了复杂的构造器链。

逐步执行流程追踪

我们从Test类的main方法开始，逐步追踪new Circle9();的执行流程：

1. new Circle9();

   • 调用Circle9类的无参构造器：public Circle9()。
   • 该构造器的第一行是 this(1.0);。

2. this(1.0);

   • 调用Circle9类的带double参数的构造器：public Circle9(double radius)。
   • 该构造器的第一行是 this(radius, "white", false);。

3. this(radius, "white", false);

   

   OpenBMB

   OpenBMB 让大模型飞入千家万户

   198

   查看详情
   • 调用Circle9类的带double, String, boolean参数的构造器：public Circle9(double radius, String color, boolean filled)。
   • 该构造器的第一行是 super(color, filled);。

4. super(color, filled);

   • 调用GeometricObject类的带String, boolean参数的构造器：public GeometricObject(String color, boolean filled)。
   • 该构造器没有显式this()或super()，因此编译器会自动插入 super();。
   • super();会调用java.lang.Object的无参构造器。

5. java.lang.Object()

   • java.lang.Object的无参构造器执行完毕（它不调用任何super()或this()，也不执行任何打印）。

6. 返回到GeometricObject(String color, boolean filled)

   • GeometricObject的带参构造器继续执行，打印 "B"。
   • 执行完毕，返回。

7. 返回到Circle9(double radius, String color, boolean filled)

   • Circle9的带参构造器继续执行，打印 "E"。
   • 执行完毕，返回。

8. 返回到Circle9(double radius)

   • Circle9的带double参数的构造器继续执行，打印 "D"。
   • 执行完毕，返回。

9. 返回到Circle9()

   • Circle9的无参构造器继续执行，打印 "C"。
   • 执行完毕。

根据上述追踪，最终的输出顺序是："BEDC"。

“A”为何被忽略？

在GeometricObject类中，存在两个构造器：

• GeometricObject()：打印"A"。
• GeometricObject(String color, boolean filled)：打印"B"。

通过上述执行流程分析，我们可以清楚地看到，Circle9类的构造器链最终通过super(color, filled)显式地调用了GeometricObject的带参数构造器。这意味着，GeometricObject的无参构造器（打印"A"的那个）从未被任何this()或super()调用链激活。由于它没有被任何有效的路径调用，其内部的打印语句自然也不会被执行。

这个例子生动地说明了，即使父类有多个构造器，也只有被构造器链明确选中的那一个（或几个，如果存在this()内部调用）会被执行。

核心总结与注意事项

总结要点

• 构造器强制调用规则：Java规定，每个构造器（除了java.lang.Object的构造器）的第一条语句必须是this()或super()。
• 隐式 super();：如果构造器没有显式调用this()或super()，编译器会自动插入super();。
• 执行顺序：构造器的实际执行顺序总是从最底层的子类开始，通过this()和super()向上追溯到java.lang.Object的构造器。然后，在父类构造器返回后，子类构造器体内的其余语句才会从上到下依次执行。
• this()与super()互斥：在一个构造器的第一行，只能出现this()或super()中的一个，不能同时存在。
• 选择性执行：构造器链决定了父类中哪个具体的构造器会被调用，未被调用的构造器中的代码将不会执行。

注意事项

• 编译时规则：构造器链的强制调用规则主要是Java编译器（javac）的约束。它确保了在编译时所有父类都能被正确初始化。
• 父类无参构造器：如果父类只定义了带参数的构造器而没有定义无参构造器，那么子类必须显式地调用父类的某个带参数构造器（即super(...)），否则编译会失败。
• java.lang.Object的特殊性：java.lang.Object是所有类的根父类，其构造器是唯一一个不调用super()或this()的构造器。
• 代码可读性：合理使用this()和super()可以提高代码的模块化和可读性，但过度复杂的构造器链也可能导致理解上的困难。在设计类层次结构时，应权衡其清晰性和功能性。

通过深入理解Java构造器链和this()、super()的工作机制，开发者可以更精确地控制对象的初始化过程，确保类层次结构中的每个组件都能得到正确且预期的初始化。

以上就是Java构造器链式调用深度解析：this()与super()的工作机制的详细内容，更多请关注php中文网其它相关文章！