Java构造器链式调用与静态变量陷阱详解

怎么入门文章编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《Java构造器链式调用与静态变量陷阱解析》，涉及到，有需要的可以收藏一下

理解Java构造器重载与this()调用

在Java中，构造器重载允许一个类拥有多个名称相同但参数列表不同的构造器，以便在创建对象时提供不同的初始化方式。this()关键字则提供了一种在同一个类的不同构造器之间进行链式调用的机制。它的主要目的是代码复用，避免在多个构造器中重复编写共同的初始化逻辑。当一个构造器通过this()调用另一个构造器时，被调用的构造器会先执行其初始化逻辑。

例如，一个类可能有一个无参构造器，它调用一个带参数的构造器来设置默认值：

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

    // 有参构造器：负责核心初始化逻辑
    public MyClass(int value, String name) {
        this.value = value;
        this.name = name;
        // 假设这里有一些通用的初始化代码
        System.out.println("有参构造器执行");
    }

    // 无参构造器：调用有参构造器设置默认值
    public MyClass() {
        this(0, "Default"); // 调用上面的有参构造器
        System.out.println("无参构造器执行");
    }

    public static void main(String[] args) {
        MyClass obj1 = new MyClass(10, "Custom"); // 输出：有参构造器执行
        MyClass obj2 = new MyClass();             // 输出：有参构造器执行, 无参构造器执行
    }
}

从上述示例可以看出，当通过new MyClass()创建对象时，无参构造器会先调用有参构造器，有参构造器执行完毕后，无参构造器剩余的代码才会继续执行。

常见陷阱：静态变量的重复初始化

在使用构造器链式调用时，一个常见的陷阱是静态变量的重复操作。静态变量属于类本身，而不是类的某个特定实例。因此，对静态变量的任何操作（如增减）都应该谨慎，确保其逻辑只被执行一次，或者以预期的次数执行。

考虑以下一个银行账户类BankAccount，它旨在统计创建的账户总数：

// BankAccount.java (存在问题版本)
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;
    }
}

以及对应的测试代码：

// Test.java
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());
    }
}

运行上述代码，预期结果是number of accounts is 3，但实际输出却是number of accounts is 4。

原因分析：

1. account1 = new BankAccount(50, 50);：调用有参构造器，numberOfAccounts变为1。
2. account2 = new BankAccount(100, 80);：调用有参构造器，numberOfAccounts变为2。
3. account3 = new BankAccount();：
   • 首先，无参构造器被调用。
   • 无参构造器内部通过this(0, 0);调用了有参构造器。
   • 有参构造器执行，将numberOfAccounts增加到3。
   • 有参构造器执行完毕后，控制权返回给无参构造器。
   • 无参构造器继续执行其剩余代码，即numberOfAccounts++;，再次将numberOfAccounts增加到4。

因此，当使用无参构造器创建对象时，numberOfAccounts被错误地增加了两次。

解决方案与最佳实践

解决上述问题的关键在于确保对静态变量的初始化或更新逻辑只在构造器链的“最终”目标构造器中执行一次。

修正后的BankAccount类：

// BankAccount.java (修正版本)
public class BankAccount {
    private double checkingBalance;
    private double savingBalance;
    private static int numberOfAccounts;

    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++;语句删除，无论通过哪个构造器创建BankAccount对象，numberOfAccounts都只会在有参构造器中被精确地增加一次。此时，运行Test.java将得到正确的输出：number of accounts is 3。

注意事项：

1. this()必须是构造器中的第一条语句：这是Java语言的强制规定，确保了链式调用在任何其他初始化逻辑之前发生。
2. 避免重复的副作用：当一个构造器通过this()调用另一个构造器时，应该将所有具有“副作用”（如修改静态变量、打印日志等）的通用初始化逻辑集中在被调用的“目标”构造器中。调用者构造器应主要负责参数转换或调用链的引导。
3. 构造器被调用的次数：当使用new关键字创建一个对象时，只有一个构造器被“直接”调用。如果这个构造器内部使用了this()进行链式调用，那么实际上会有一个构造器链被执行。但从外部视角来看，每次new操作都对应一次对象创建。对于静态变量的增减，应确保每次对象创建只导致其增加一次（除非业务逻辑另有规定）。

总结

Java中的构造器重载和this()链式调用是强大的特性，有助于代码复用和提高可维护性。然而，在使用它们时，尤其涉及到静态变量的更新，必须仔细设计，避免因重复执行初始化逻辑而导致数据不一致。最佳实践是将对静态变量的修改或任何一次性副作用操作放在构造器链的“最底层”或“最终”构造器中，确保每次对象创建都精确地执行一次所需的操作。

到这里，我们也就讲完了《Java构造器链式调用与静态变量陷阱详解》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！