Java构造器重载与this()调用计数陷阱详解

理解Java构造器与重载

在Java中，构造器（Constructor）是一种特殊的方法，用于创建并初始化对象。当一个类被实例化时，其构造器会被调用。构造器可以被重载，这意味着一个类可以有多个同名但参数列表不同的构造器。这为开发者提供了灵活的方式来初始化对象，以适应不同的创建场景。

例如，一个BankAccount类可能有一个无参构造器，用于创建默认账户，以及一个带参数的构造器，用于创建带有初始余额的账户。

public class BankAccount {
    private double checkingBalance;
    private double savingBalance;
    private static int numberOfAccounts; // 静态变量，用于统计账户数量

    // 无参构造器
    public BankAccount() {
        // 假设这里会调用另一个构造器进行实际初始化
    }

    // 带参数的构造器
    public BankAccount(double checkingInitial, double savingInitial) {
        this.checkingBalance = checkingInitial;
        this.savingBalance = savingInitial;
        numberOfAccounts++; // 在这里递增账户计数
    }

    public static int getNumberOfAccounts() {
        return numberOfAccounts;
    }
}

this()关键字：构造器链式调用

Java中的this()关键字在一个构造器内部用于调用同一个类的另一个构造器。这被称为构造器链式调用（Constructor Chaining），它是一种代码复用的有效方式，允许一个构造器执行一些通用初始化，然后将控制权传递给另一个更具体的构造器来完成剩余的初始化。

例如，在上述BankAccount类中，无参构造器可以利用this(0, 0)来调用带参数的构造器，从而避免重复编写初始余额设置为零的逻辑：

public class BankAccount {
    private double checkingBalance;
    private double savingBalance;
    private static int numberOfAccounts;

    public BankAccount() {
        this(0, 0); // 调用带参数的构造器
        // numberOfAccounts++; // 错误：此处不应再次递增
    }

    public BankAccount(double checkingInitial, double savingInitial) {
        this.checkingBalance = checkingInitial;
        this.savingBalance = savingInitial;
        numberOfAccounts++; // 正确：只在这里递增一次
    }

    public static int getNumberOfAccounts() {
        return numberOfAccounts;
    }
}

常见陷阱：静态变量的重复递增

在上述BankAccount的初始设计中，存在一个常见的陷阱：当无参构造器通过this(0, 0)调用带参数构造器时，numberOfAccounts变量会被递增一次。如果无参构造器内部也包含numberOfAccounts++，那么在每次通过无参构造器创建对象时，numberOfAccounts就会被错误地递增两次。

考虑以下测试代码：

public class Test {
    public static void main(String[] args) {
        BankAccount account1 = new BankAccount(50, 50); // 调用带参构造器，numberOfAccounts = 1
        BankAccount account2 = new BankAccount(100, 80); // 调用带参构造器，numberOfAccounts = 2
        BankAccount account3 = new BankAccount();       // 调用无参构造器，然后无参构造器再调用带参构造器

        System.out.println("number of accounts is " + BankAccount.getNumberOfAccounts());
    }
}

如果无参构造器被错误地写成：

public BankAccount() {
    this(0, 0);
    numberOfAccounts++; // 错误：这里会再次递增
}

那么当account3被创建时，会发生以下步骤：

1. new BankAccount() 调用无参构造器。
2. 无参构造器内部执行 this(0, 0)，这会调用带参数构造器。
3. 带参数构造器执行 numberOfAccounts++，此时 numberOfAccounts 从 2 变为 3。
4. 带参数构造器执行完毕，控制权返回给无参构造器。
5. 无参构造器继续执行其内部的 numberOfAccounts++，此时 numberOfAccounts 从 3 变为 4。

最终，System.out.println会输出 "number of accounts is 4"，而不是预期的 3。

解决方案与最佳实践

解决这个问题的关键在于理解this()调用的行为：当一个构造器通过this()调用另一个构造器时，被调用的构造器会负责完成所有的初始化工作，包括对静态变量的更新。因此，调用this()的构造器不应该重复执行这些初始化逻辑。

正确的BankAccount类实现应如下所示：

public class BankAccount {
    private double checkingBalance;
    private double savingBalance;
    private static int numberOfAccounts;

    // 无参构造器：通过this()调用带参数构造器，将初始化工作委托出去
    public BankAccount() {
        this(0, 0); // 正确：只调用一次
    }

    // 带参数的构造器：负责实际的初始化和静态变量的递增
    public BankAccount(double checkingInitial, double savingInitial) {
        this.checkingBalance = checkingInitial;
        this.savingBalance = savingInitial;
        numberOfAccounts++; // 正确：只在这里递增一次
    }

    public static int getNumberOfAccounts() {
        return numberOfAccounts;
    }
}

通过移除无参构造器中的numberOfAccounts++，确保了无论通过哪个构造器创建对象，numberOfAccounts都只会被递增一次。

构造器调用次数的理解

回到标题中的问题：“当构造器重载时，它会被调用多少次？”

对于每次使用new关键字创建对象的操作，从外部看，只有一个构造器被“直接”调用。这个直接调用的构造器可以是无参的，也可以是带参数的，取决于你提供的参数列表。

然而，如果这个“直接”调用的构造器内部又使用了this()来调用同一个类的另一个构造器，那么实际上会形成一个构造器链。在这个链中，一个构造器会显式地调用另一个构造器。但这并不意味着“多个”构造器被独立地调用来创建同一个对象。相反，它们是协同工作，共同完成一个对象的初始化过程。

所以，对于new BankAccount()，表面上你调用了无参构造器。但由于无参构造器内部的this(0, 0)，它又委托给了带参构造器来完成初始化。整个过程仍然是为一个新对象服务，且numberOfAccounts这种静态计数器应该只在链条的“末端”或“核心”构造器中处理一次。

总结

在使用Java构造器重载和this()进行链式调用时，务必注意静态变量的初始化逻辑。最佳实践是将所有公共的初始化操作（包括对静态计数器的更新）放在构造器链中最“基础”或最“核心”的那个构造器中。其他通过this()调用这个核心构造器的构造器，则不应重复执行这些操作，以避免逻辑错误和不一致的数据状态。清晰地理解构造器链的工作原理是编写健壮、可维护Java代码的关键。