Java构造器重载与静态变量计数技巧

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《Java构造器重载中静态变量计数技巧》，聊聊，我们一起来看看吧！

理解构造器重载与链式调用

在Java中，构造器重载允许一个类拥有多个构造器，它们具有相同的名称但参数列表不同。这为对象创建提供了灵活性，可以根据不同的初始化需求选择合适的构造器。

构造器链式调用（Constructor Chaining）是构造器重载的一个重要特性，它允许一个构造器通过 this(...) 关键字调用同一个类的另一个构造器。这种机制的主要目的是实现代码复用，避免在多个构造器中重复编写初始化逻辑。例如，一个无参构造器可以调用一个带参构造器，为其提供默认值。

考虑以下 BankAccount 类的初始实现：

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;
    }
}

以及对应的测试代码：

public class Test {
    public static void main(String[] args) {
        BankAccount account1 = new BankAccount(50, 50);
        BankAccount account2 = new BankAccount(100, 80);
        BankAccount account3 = new BankAccount(); // 使用无参构造器

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

当运行上述 Test 类时，预期输出是 number of accounts is 3，因为我们创建了三个 BankAccount 实例。然而，实际输出却是 number of accounts is 4。

静态变量重复递增的陷阱

出现 numberOfAccounts 计数错误的原因在于对静态变量 numberOfAccounts 的递增操作被执行了不止一次，特别是当无参构造器被调用时。让我们详细分析 BankAccount account3 = new BankAccount(); 这一行代码的执行流程：

1. 调用无参构造器 BankAccount(): 当 new BankAccount() 被执行时，首先进入 BankAccount 类的无参构造器。
2. 执行 this(0, 0);: 在无参构造器内部，第一行代码是 this(0, 0);。这会立即将控制权转移到带参构造器 BankAccount(double checkingInitial, double savingInitial)。
3. 带参构造器执行:
   • this.checkingBalance = 0; 和 this.savingBalance = 0; 完成余额初始化。
   • numberOfAccounts++; 执行，此时 numberOfAccounts 的值递增。
4. 返回无参构造器继续执行: 带参构造器执行完毕后，控制权返回到无参构造器中 this(0, 0); 语句的下一行。
5. 无参构造器再次递增: numberOfAccounts++; 再次执行，使得 numberOfAccounts 的值再次递增。

因此，对于通过无参构造器创建的每一个 BankAccount 实例，numberOfAccounts 实际上被递增了两次。而通过带参构造器创建的实例，numberOfAccounts 只被递增一次，这是符合预期的。这种重复递增导致了最终计数的不准确。

解决方案：确保静态变量单次更新

解决这个问题的关键是确保静态变量 numberOfAccounts 在每个 BankAccount 对象被创建时，只被递增一次。最直接的办法是将 numberOfAccounts++ 操作只放在构造器链的“最终”构造器中，或者确保无论哪个构造器被调用，它都只通过一个唯一的路径来更新静态变量。

修改后的 BankAccount 类如下：

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;
    }
}

在修正后的代码中，我们移除了无参构造器中的 numberOfAccounts++;。现在，无论是直接调用带参构造器，还是通过无参构造器链式调用带参构造器，numberOfAccounts 都只会在带参构造器中被递增一次。

使用修正后的 BankAccount 类运行 Test 代码，将得到正确的输出：number of accounts is 3。

构造器调用次数的澄清

关于“当构造器重载时，构造器被调用了多少次？”这个问题，需要明确一点：

• 直接调用： 当你使用 new 关键字创建一个对象时，JVM 会直接调用你指定的那个构造器（例如 new BankAccount() 或 new BankAccount(50, 50)）。从这个意义上说，只有一个构造器被直接“调用”来创建对象实例。
• 链式调用： 然而，这个被直接调用的构造器内部可能会通过 this(...) 关键字进一步调用同一个类的另一个构造器。这种情况下，虽然只有一个构造器是外部直接触发的，但内部会形成一个构造器执行链。例如，new BankAccount() 会导致 BankAccount() 构造器被执行，而 BankAccount() 又会内部调用 BankAccount(double, double) 构造器。所以，一个对象创建过程可能涉及多个构造器的执行，但它们都是为了完成同一个对象的初始化。

关键在于，无论有多少个构造器参与了初始化链，一个对象的创建过程只发生一次，并且所有初始化逻辑都应该围绕这个单一的创建过程进行协调。

最佳实践与注意事项

1. 单一职责原则在构造器中的体现： 对于共享的静态资源（如计数器），应尽量确保其更新逻辑集中在一个地方，或者至少保证其在整个构造器链中只被执行一次。通常，将这类逻辑放在构造器链中最终被调用的那个构造器（通常是参数最多的那个，因为它包含了所有必要的初始化信息）是一个好的实践。

2. 线程安全： 在多线程环境中，numberOfAccounts++ 这样的操作不是原子性的，可能导致竞态条件和不准确的计数。对于生产级代码，应考虑使用 java.util.concurrent.atomic.AtomicInteger 类来保证原子性操作，或者使用 synchronized 关键字进行同步。

   // 使用 AtomicInteger 替代 int
   private static AtomicInteger numberOfAccounts = new AtomicInteger(0);
   
   // 在构造器中
   public BankAccount(double checkingInitial, double savingInitial) {
       this.checkingBalance = checkingInitial;
       this.savingBalance = savingInitial;
       numberOfAccounts.incrementAndGet(); // 原子性递增
   }
   
   public static int getNumberOfAccounts() {
       return numberOfAccounts.get();
   }

3. 避免在构造器中执行复杂逻辑： 构造器应主要用于初始化实例变量。避免在构造器中执行耗时或可能抛出异常的复杂逻辑，这会影响对象创建的性能和稳定性。

4. 明确构造器链的意图： 在设计构造器重载和链式调用时，应清晰地规划每个构造器的职责，并确保它们协同工作以正确初始化对象状态。

总结

通过本教程，我们深入理解了Java构造器重载、链式调用以及在其中管理静态变量时可能遇到的陷阱。核心教训是，当使用 this(...) 进行构造器链式调用时，必须仔细审查静态变量的更新逻辑，确保其在每个对象创建过程中只被执行一次，以避免数据不一致。遵循单一职责原则，并考虑并发环境下的线程安全问题，是编写健壮、可维护Java代码的关键。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Java构造器重载与静态变量计数技巧》文章吧，也可关注golang学习网公众号了解相关技术文章。