12、JDK 23 新特性：灵活的构造函数体（JEP 482）：构造函数初始化代码的灵活性增强

写Java类的时候，最烦的就是构造函数的限制了，特别是需要在调用父类构造函数之前做参数验证或者字段初始化的时候，传统方式构造函数的首条语句必须是super()或this()，不能在这之前写其他代码，有时候就得用辅助方法或者中间构造函数，代码写起来麻烦。JDK 23的JEP 482整了个新活，允许在显式构造函数调用之前添加语句，让构造函数初始化代码更灵活了。

鹏磊我之前写类的时候，经常遇到这种情况，需要在调用父类构造函数之前验证参数，但是Java不允许，只能先调用super()，然后在构造函数体里验证，但是这时候对象已经部分初始化了，验证失败的话对象状态就不一致了。或者用辅助方法，但是代码就复杂了。

现在有了灵活的构造函数体，可以在super()或this()之前写代码，做参数验证、字段初始化这些，只要不引用正在构建的实例就行。这样代码更清晰，逻辑也更合理。

JEP 482 的核心特性

JEP 482允许在构造函数的显式构造函数调用（super()或this()）之前添加语句。这些语句不能引用正在构建的实例，但可以用于参数验证、字段初始化等操作。

传统构造函数的限制

在传统的Java中，构造函数的首条语句必须是显式构造函数调用：

// 传统方式，首条语句必须是super()或this()
public class PositiveBigInteger extends BigInteger {
    public PositiveBigInteger(long value) {
        super(value);  // 必须是首条语句
        // 这里才能写其他代码，但是对象已经部分初始化了
        if (value <= 0) {
            throw new IllegalArgumentException("Value must be positive");
        }
    }
}

这种方式有问题，如果参数验证失败，对象已经部分初始化了，状态不一致。

灵活构造函数体的优势

有了JEP 482，可以在super()之前写代码：

// 新方式，可以在super()之前写代码
public class PositiveBigInteger extends BigInteger {
    public PositiveBigInteger(long value) {
        if (value <= 0) {
            throw new IllegalArgumentException("Value must be positive");
        }
        super(value);  // 验证通过后再调用父类构造函数
    }
}

这样参数验证在对象初始化之前完成，更安全。

使用场景

场景1：参数验证

最常见的场景就是在调用父类构造函数之前验证参数：

// 参数验证场景
public class Rectangle {
    private final int width;
    private final int height;
    
    public Rectangle(int width, int height) {
        // 在调用父类构造函数之前验证参数
        if (width <= 0 || height <= 0) {
            throw new IllegalArgumentException("Width and height must be positive");
        }
        super();  // 调用父类构造函数
        this.width = width;
        this.height = height;
    }
}

这样验证失败的时候，对象还没有初始化，状态一致。

场景2：字段初始化

可以在调用父类构造函数之前初始化字段：

// 字段初始化场景
public class DatabaseConnection extends Connection {
    private final String connectionString;
    private final Properties properties;
    
    public DatabaseConnection(String url, Properties props) {
        // 在调用父类构造函数之前初始化字段
        this.connectionString = url;
        this.properties = new Properties(props);  // 创建副本，避免外部修改
        super(connectionString, properties);  // 调用父类构造函数
    }
}

这样字段在父类构造函数调用之前就初始化好了。

场景3：计算派生值

可以在调用父类构造函数之前计算派生值：

// 计算派生值场景
public class Circle extends Shape {
    private final double radius;
    private final double area;
    
    public Circle(double radius) {
        // 在调用父类构造函数之前计算派生值
        if (radius <= 0) {
            throw new IllegalArgumentException("Radius must be positive");
        }
        this.radius = radius;
        this.area = Math.PI * radius * radius;  // 计算面积
        super("Circle", area);  // 调用父类构造函数，传入计算好的面积
    }
}

这样派生值在父类构造函数调用之前就计算好了。

场景4：条件初始化

可以根据条件进行不同的初始化：

// 条件初始化场景
public class ConfigurableLogger extends Logger {
    private final LogLevel level;
    private final String format;
    
    public ConfigurableLogger(String name, LogLevel level) {
        // 在调用父类构造函数之前根据条件初始化
        this.level = level;
        if (level == LogLevel.DEBUG) {
            this.format = "%s [DEBUG] %s";  // Debug模式用详细格式
        } else {
            this.format = "%s %s";  // 其他模式用简单格式
        }
        super(name, format);  // 调用父类构造函数，传入格式化字符串
    }
}

这样可以根据条件进行不同的初始化。

限制和规则

不能引用正在构建的实例

在显式构造函数调用之前的语句，不能引用正在构建的实例：

// 错误：不能引用正在构建的实例
public class Example {
    private int value;
    
    public Example(int value) {
        this.value = value;  // 错误！不能引用this
        if (this.value < 0) {  // 错误！不能引用this
            throw new IllegalArgumentException();
        }
        super();
    }
}

// 正确：不引用this
public class Example {
    private int value;
    
    public Example(int value) {
        if (value < 0) {  // 正确，使用参数，不引用this
            throw new IllegalArgumentException();
        }
        super();
        this.value = value;  // 正确，在super()之后可以引用this
    }
}

在super()或this()之前，不能使用this关键字，也不能访问实例字段或方法。

可以使用静态方法和字段

可以使用静态方法和字段：

// 可以使用静态方法和字段
public class ValidatedString extends String {
    public ValidatedString(String value) {
        // 可以使用静态方法验证
        if (!StringUtils.isValid(value)) {  // 静态方法，可以调用
            throw new IllegalArgumentException("Invalid string");
        }
        super(value);
    }
}

class StringUtils {
    public static boolean isValid(String s) {
        return s != null && !s.isEmpty();
    }
}

静态方法和字段不依赖实例，可以在super()之前使用。

可以使用局部变量

可以使用局部变量进行计算：

// 可以使用局部变量
public class ComplexNumber extends Number {
    private final double real;
    private final double imaginary;
    
    public ComplexNumber(double real, double imaginary) {
        // 可以使用局部变量进行计算
        double magnitude = Math.sqrt(real * real + imaginary * imaginary);
        if (magnitude == 0) {
            throw new IllegalArgumentException("Magnitude cannot be zero");
        }
        super(magnitude);
        this.real = real;
        this.imaginary = imaginary;
    }
}

局部变量不依赖实例，可以在super()之前使用。

与传统方式的对比

代码复杂度对比

传统方式需要用辅助方法或者中间构造函数：

// 传统方式，用辅助方法
public class PositiveBigInteger extends BigInteger {
    public PositiveBigInteger(long value) {
        super(validateAndGetValue(value));  // 用辅助方法验证
    }
    
    private static long validateAndGetValue(long value) {
        if (value <= 0) {
            throw new IllegalArgumentException("Value must be positive");
        }
        return value;
    }
}

灵活构造函数体方式，代码更直接：

// 新方式，直接验证
public class PositiveBigInteger extends BigInteger {
    public PositiveBigInteger(long value) {
        if (value <= 0) {
            throw new IllegalArgumentException("Value must be positive");
        }
        super(value);  // 直接调用，代码更清晰
    }
}

代码更简洁，逻辑也更直观。

错误处理对比

传统方式，如果验证失败，对象可能已经部分初始化：

// 传统方式，对象可能已经部分初始化
public class Rectangle {
    private final int width;
    private final int height;
    
    public Rectangle(int width, int height) {
        super();  // 先调用父类构造函数，对象已经部分初始化
        if (width <= 0 || height <= 0) {
            throw new IllegalArgumentException();  // 验证失败，但对象已经初始化了
        }
        this.width = width;
        this.height = height;
    }
}

灵活构造函数体方式，验证在对象初始化之前完成：

// 新方式，验证在对象初始化之前完成
public class Rectangle {
    private final int width;
    private final int height;
    
    public Rectangle(int width, int height) {
        if (width <= 0 || height <= 0) {
            throw new IllegalArgumentException();  // 验证失败，对象还没初始化
        }
        super();  // 验证通过后才初始化对象
        this.width = width;
        this.height = height;
    }
}

这样更安全，对象状态更一致。

代码可读性对比

传统方式，逻辑分散在多个地方：

// 传统方式，逻辑分散
public class ConfigurableService extends Service {
    private final String config;
    
    public ConfigurableService(String config) {
        super(processConfig(config));  // 处理逻辑在辅助方法里
    }
    
    private static String processConfig(String config) {
        if (config == null || config.isEmpty()) {
            throw new IllegalArgumentException("Config cannot be empty");
        }
        return config.toUpperCase();
    }
}

灵活构造函数体方式，逻辑集中在一个地方：

// 新方式，逻辑集中
public class ConfigurableService extends Service {
    private final String config;
    
    public ConfigurableService(String config) {
        // 处理逻辑直接在构造函数里
        if (config == null || config.isEmpty()) {
            throw new IllegalArgumentException("Config cannot be empty");
        }
        super(config.toUpperCase());  // 直接处理并调用
    }
}

代码更易读，逻辑更清晰。

实际应用示例

示例1：验证并转换参数

// 验证并转换参数
public class EmailAddress extends String {
    public EmailAddress(String email) {
        // 在调用父类构造函数之前验证和转换
        if (email == null || email.isEmpty()) {
            throw new IllegalArgumentException("Email cannot be empty");
        }
        String normalized = email.trim().toLowerCase();  // 规范化
        if (!isValidEmail(normalized)) {
            throw new IllegalArgumentException("Invalid email format");
        }
        super(normalized);  // 调用父类构造函数，传入规范化后的邮箱
    }
    
    private static boolean isValidEmail(String email) {
        return email.contains("@") && email.contains(".");
    }
}

这样邮箱地址在创建之前就被验证和规范化了。

示例2：根据参数计算字段

// 根据参数计算字段
public class Point3D extends Point2D {
    private final double x;
    private final double y;
    private final double z;
    private final double distance;
    
    public Point3D(double x, double y, double z) {
        // 在调用父类构造函数之前计算距离
        this.x = x;
        this.y = y;
        this.z = z;
        this.distance = Math.sqrt(x * x + y * y + z * z);  // 计算到原点的距离
        super(x, y);  // 调用父类构造函数，传入x和y
    }
    
    public double getDistance() {
        return distance;
    }
}

这样距离在对象创建之前就计算好了。

示例3：条件初始化

// 条件初始化
public class SmartCache extends Cache {
    private final int maxSize;
    private final EvictionPolicy policy;
    
    public SmartCache(int maxSize, boolean lru) {
        // 在调用父类构造函数之前根据条件初始化
        if (maxSize <= 0) {
            throw new IllegalArgumentException("Max size must be positive");
        }
        this.maxSize = maxSize;
        this.policy = lru ? EvictionPolicy.LRU : EvictionPolicy.FIFO;  // 根据参数选择策略
        super(maxSize, policy);  // 调用父类构造函数
    }
}

这样策略在对象创建之前就确定了。

示例4：多参数验证

// 多参数验证
public class DateRange extends Range {
    private final LocalDate start;
    private final LocalDate end;
    
    public DateRange(LocalDate start, LocalDate end) {
        // 在调用父类构造函数之前验证多个参数
        if (start == null || end == null) {
            throw new IllegalArgumentException("Start and end dates cannot be null");
        }
        if (start.isAfter(end)) {
            throw new IllegalArgumentException("Start date must be before end date");
        }
        this.start = start;
        this.end = end;
        super(start, end);  // 调用父类构造函数
    }
}

这样多个参数的验证在对象创建之前就完成了。

启用预览特性

JEP 482是预览特性，得先启用才能用：

# 编译时启用预览特性
javac --enable-preview --release 23 MyClass.java

# 运行时启用预览特性
java --enable-preview MyClass

Maven配置

如果用Maven，可以在pom.xml里配置：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <release>23</release>
                <compilerArgs>
                    <arg>--enable-preview</arg>
                </compilerArgs>
            </configuration>
        </plugin>
    </plugins>
</build>

Gradle配置

如果用Gradle，可以在build.gradle里配置：

tasks.withType(JavaCompile) {
    options.compilerArgs += '--enable-preview'
    options.release = 23
}

tasks.withType(JavaExec) {
    jvmArgs += '--enable-preview'
}

最佳实践

1. 用于参数验证

灵活构造函数体最适合用于参数验证：

// 好的做法：用于参数验证
public class ValidatedValue extends Value {
    public ValidatedValue(String value) {
        if (value == null || value.isEmpty()) {
            throw new IllegalArgumentException("Value cannot be null or empty");
        }
        super(value);
    }
}

2. 用于字段初始化

可以用于在调用父类构造函数之前初始化字段：

// 好的做法：用于字段初始化
public class InitializedClass extends BaseClass {
    private final String processed;
    
    public InitializedClass(String input) {
        this.processed = processInput(input);  // 初始化字段
        super(processed);
    }
    
    private static String processInput(String input) {
        return input.trim().toUpperCase();
    }
}

3. 避免复杂逻辑

不要在super()之前写太复杂的逻辑，保持代码简洁：

// 好的做法：逻辑简单清晰
public class SimpleClass extends BaseClass {
    public SimpleClass(int value) {
        if (value < 0) {
            throw new IllegalArgumentException();
        }
        super(value);
    }
}

// 不好的做法：逻辑太复杂
public class ComplexClass extends BaseClass {
    public ComplexClass(int value) {
        // 太多逻辑，代码难读
        int processed = value;
        for (int i = 0; i < 10; i++) {
            processed = process(processed);
        }
        if (processed < 0) {
            throw new IllegalArgumentException();
        }
        super(processed);
    }
}

4. 保持一致性

在团队项目中，保持使用方式的一致性：

// 团队统一的做法
public class TeamClass extends BaseClass {
    public TeamClass(String value) {
        // 统一在super()之前验证参数
        validate(value);
        super(value);
    }
    
    private static void validate(String value) {
        if (value == null || value.isEmpty()) {
            throw new IllegalArgumentException();
        }
    }
}

总结

JEP 482引入的灵活构造函数体，确实让构造函数初始化代码变得更灵活了。特别是参数验证和字段初始化，可以在对象创建之前完成，更安全，代码也更清晰。

鹏磊我觉得这个特性还是挺有用的，特别是那些需要在对象创建之前验证参数或者初始化字段的场景，用灵活构造函数体代码更直接，逻辑也更合理。虽然现在还是预览特性，但是未来应该会稳定下来，成为Java开发的常用特性。

总的来说，灵活构造函数体是Java构造函数系统的一个很好的补充，让构造函数初始化代码变得更灵活、更安全。虽然功能看起来简单，但是在实际开发中能解决不少问题，让代码质量更高。