鹏磊我在写 Java 代码时，经常遇到构造函数的一个长期限制：如果显式调用 super() 或 this()，这个调用必须是构造函数的第一行。这个限制导致了一个常见问题：无法在调用父类构造函数之前进行参数验证或参数转换。
JEP 513 的灵活构造函数体打破了这一限制。现在，你可以在显式构造函数调用之前执行验证、计算或其他操作，然后再调用父类构造函数。鹏磊我觉得这不仅让代码逻辑更加合理（先验证再构造），还提高了代码的可读性和安全性。对于需要参数验证或参数转换的构造函数，这个特性特别有用。
灵活构造函数体是啥
灵活构造函数体（Flexible Constructor Bodies）就是允许你在构造函数中，在显式调用 super() 或 this() 之前，先执行一些语句。这些语句可以验证参数、计算参数、初始化字段等等。
以前 Java 的构造函数有个硬性规定：如果构造函数里有显式调用 super() 或 this()，那这个调用必须是第一行。这就导致很多场景下代码写起来很别扭。
比如你想在调用父类构造函数之前先验证参数，以前就得这样写：
public class PositiveBigInteger extends BigInteger {
public PositiveBigInteger(long value) {
// 以前不行，必须先调用 super()
// if (value <= 0) throw new IllegalArgumentException("...");
super(Long.toString(value)); // 必须先调用这个
// 验证得放后面，但是这时候父类已经构造完了
}
}
现在可以这样写：
public class PositiveBigInteger extends BigInteger {
public PositiveBigInteger(long value) {
// 现在可以先验证参数了
if (value <= 0) {
throw new IllegalArgumentException("值必须大于 0"); // 先验证
}
super(Long.toString(value)); // 然后再调用父类构造函数
}
}
这样写更合理，在调用父类构造函数之前就把无效的参数过滤掉了，不用浪费资源去构造一个无效的对象。
构造函数体的结构
灵活构造函数体把构造函数分成了两部分：前序（Prologue）和后序（Epilogue）。
前序（Prologue）
前序就是在显式构造函数调用（super() 或 this()）之前的那些语句。在前序里，你可以：
- 验证构造函数参数
- 计算传给父类构造函数的参数
- 初始化实例字段
但是有个限制：不能访问正在构造的实例，也就是说不能用 this、不能调用实例方法、不能访问实例字段。
public class Example extends Parent {
private int computedValue; // 实例字段
public Example(int value) {
// 前序部分：在 super() 调用之前
if (value < 0) {
throw new IllegalArgumentException("值不能为负"); // 验证参数，可以
}
int processed = value * 2; // 计算参数，可以
String str = String.valueOf(processed); // 准备参数，可以
computedValue = 10; // 初始化字段，可以
// this.computedValue = 10; // 这样不行，不能用 this
// this.someMethod(); // 这样也不行，不能调用实例方法
super(str); // 显式构造函数调用
// 后序部分：在 super() 调用之后
// 这里可以正常使用 this 和实例方法了
}
}
后序（Epilogue）
后序就是在显式构造函数调用之后的那些语句。这部分和以前一样，可以正常使用 this、调用实例方法、访问实例字段。
public class Example extends Parent {
private String name;
private int count;
public Example(String name, int count) {
// 前序：验证和准备
if (name == null || name.isEmpty()) {
throw new IllegalArgumentException("名字不能为空"); // 验证参数
}
super(name); // 调用父类构造函数
// 后序：可以正常使用 this 了
this.name = name; // 可以访问实例字段
this.count = count; // 可以设置字段
this.initialize(); // 可以调用实例方法
}
private void initialize() {
// 初始化逻辑
}
}
实际应用场景
这个特性在实际开发中还是挺有用的，特别是下面这些场景：
场景一：参数验证
最常见的场景就是在调用父类构造函数之前验证参数，避免构造无效对象。
// 表示正整数的类
public class PositiveInteger extends Number {
public PositiveInteger(int value) {
// 先验证参数，无效就直接抛异常，不用构造对象
if (value <= 0) {
throw new IllegalArgumentException("必须是正整数: " + value); // 验证失败就抛异常
}
super(); // 验证通过再调用父类构造函数
}
@Override
public int intValue() {
return value; // 返回整数值
}
// 其他方法...
}
这样写的好处是，如果参数无效，直接就在构造函数里抛异常了，不用等对象构造完再检查。
场景二：参数转换和计算
有时候需要把参数转换一下，或者计算一下，再传给父类构造函数。
// 表示范围的类
public class Range extends AbstractRange {
public Range(int start, int end) {
// 前序：计算和转换参数
int min = Math.min(start, end); // 计算最小值
int max = Math.max(start, end); // 计算最大值
// 确保范围有效
if (min < 0) {
throw new IllegalArgumentException("起始值不能为负"); // 验证最小值
}
super(min, max); // 把计算好的参数传给父类
}
}
这样可以在调用父类构造函数之前就把参数处理好，父类构造函数收到的就是处理好的参数。
场景三：字段初始化
可以在调用父类构造函数之前初始化一些字段，这样这些字段在父类构造函数执行时就已经有值了。
public class ConfigurableProcessor extends BaseProcessor {
private final String config; // 配置信息
private final boolean enabled; // 是否启用
public ConfigurableProcessor(String config, boolean enabled) {
// 前序：初始化字段
this.config = config != null ? config : "default"; // 初始化配置，但是不能用 this，所以这样写不行
// 实际上在前序里不能直接给实例字段赋值（不能用 this）
// 但是可以给局部变量赋值，然后在后序里赋值给字段
String processedConfig = config != null ? config : "default"; // 先处理配置
boolean processedEnabled = enabled; // 处理启用标志
super(processedConfig); // 调用父类构造函数，传处理好的配置
// 后序：现在可以给字段赋值了
this.config = processedConfig; // 赋值给字段
this.enabled = processedEnabled; // 赋值给字段
}
}
等等，我刚才说错了。在前序里不能用 this，所以不能直接给实例字段赋值。但是可以给局部变量赋值，然后在后序里赋值给字段。或者，如果字段是 final 的，可以在前序里通过其他方式初始化。
让我重新写个例子：
public class ConfigurableProcessor extends BaseProcessor {
private final String config; // final 字段
private final boolean enabled; // final 字段
public ConfigurableProcessor(String config, boolean enabled) {
// 前序：处理和验证
String processedConfig = config != null ? config : "default"; // 处理配置字符串
if (processedConfig.isEmpty()) {
throw new IllegalArgumentException("配置不能为空"); // 验证配置
}
super(processedConfig); // 调用父类构造函数
// 后序：初始化 final 字段
// 但是 final 字段必须在构造函数结束前初始化
// 所以如果要在后序初始化，字段不能是 final 的
this.config = processedConfig; // 在后序里赋值
this.enabled = enabled; // 在后序里赋值
}
}
如果字段是 final 的，那必须在构造函数结束前初始化。如果要在前序里就准备好值，可以在后序里赋值。但是前序里不能用 this，所以不能直接赋值。
场景四：条件构造
根据参数的不同，决定调用哪个父类构造函数，或者传不同的参数。
public class SmartContainer extends BaseContainer {
public SmartContainer(Object... items) {
// 前序：根据参数决定构造方式
if (items == null || items.length == 0) {
super(10); // 没参数就用默认容量
} else {
// 计算需要的容量
int capacity = items.length * 2; // 容量是元素数量的两倍
if (capacity < 10) {
capacity = 10; // 最小容量是 10
}
super(capacity); // 有参数就用计算的容量
}
// 后序：添加元素
if (items != null) {
for (Object item : items) {
addItem(item); // 添加元素，这个方法在父类或当前类里
}
}
}
}
这样可以根据参数的不同，灵活地决定怎么构造对象。
限制和注意事项
虽然这个特性挺方便的，但是也有一些限制需要注意：
1. 前序里不能访问实例
在前序里，不能使用 this、不能调用实例方法、不能访问实例字段。这是因为在调用 super() 之前，对象还没有完全构造好。
public class Example extends Parent {
private int value;
public Example(int v) {
// value = v; // 这样不行，不能访问实例字段
// this.value = v; // 这样也不行，不能用 this
// someMethod(); // 这样也不行，不能调用实例方法
int local = v; // 但是可以用局部变量
super(local); // 调用父类构造函数
// 后序里就可以正常使用了
this.value = v; // 可以赋值
this.someMethod(); // 可以调用方法
}
}
2. 前序里可以初始化字段（但不能用 this）
虽然不能用 this，但是可以直接给字段赋值（不用 this），只要不访问其他实例成员就行。
public class Example extends Parent {
private int value; // 非 final 字段
private String name; // 非 final 字段
public Example(int v, String n) {
// 可以直接给字段赋值，不用 this
value = v; // 这样可以，直接赋值
name = n != null ? n : "default"; // 这样也可以
// 但是不能这样：
// this.value = v; // 不能用 this
// if (this.value > 0) { ... } // 不能访问字段
super(); // 调用父类构造函数
}
}
等等，我再确认一下。根据 JEP 513 的规范，前序里不能访问实例字段。所以直接赋值 value = v 应该也是不行的，因为这是在访问实例字段。
让我查一下规范... 根据规范，前序里不能：
- 使用 this 或 super（除了显式构造函数调用）
- 调用实例方法
- 访问实例字段
所以 value = v 这种写法应该也是不行的，因为这是在给实例字段赋值。
正确的做法是：
public class Example extends Parent {
private int value;
private String name;
public Example(int v, String n) {
// 前序：只能用局部变量
int processedValue = v; // 用局部变量
String processedName = n != null ? n : "default"; // 用局部变量
super(); // 调用父类构造函数
// 后序：现在可以给字段赋值了
this.value = processedValue; // 赋值给字段
this.name = processedName; // 赋值给字段
}
}
3. 前序里可以做什么
前序里可以：
- 使用局部变量
- 调用静态方法
- 访问静态字段
- 验证参数
- 计算和转换参数
- 抛出异常
public class Example extends Parent {
private static int counter = 0; // 静态字段
public Example(String name) {
// 前序：可以做的操作
if (name == null) {
throw new IllegalArgumentException("名字不能为空"); // 可以抛异常
}
String processed = name.trim().toLowerCase(); // 可以处理字符串
int length = processed.length(); // 可以计算
counter++; // 可以访问静态字段
String result = String.valueOf(counter); // 可以调用静态方法
super(result); // 调用父类构造函数
}
}
4. 如果没有显式构造函数调用
如果构造函数里没有显式调用 super() 或 this()，那编译器会自动在开头插入 super()，所以整个构造函数体都是"后序"。
public class Example extends Parent {
public Example() {
// 没有显式调用 super()，编译器会自动插入
// 所以这里整个都是"后序"，可以正常使用 this
this.value = 10; // 可以访问字段
this.initialize(); // 可以调用方法
}
}
与传统方式的对比
咱们对比一下传统方式和新的灵活构造函数体方式：
传统方式
public class PositiveBigInteger extends BigInteger {
public PositiveBigInteger(long value) {
// 必须先调用 super()，验证得放后面
super(Long.toString(value)); // 先构造父类
// 验证得放后面，但是这时候父类已经构造完了
if (value <= 0) {
throw new IllegalArgumentException("值必须大于 0"); // 验证放后面
// 但是父类已经构造了，浪费资源
}
}
}
问题：
- 如果参数无效，父类已经构造了，浪费资源
- 代码逻辑不直观，验证应该在构造之前
灵活构造函数体方式
public class PositiveBigInteger extends BigInteger {
public PositiveBigInteger(long value) {
// 先验证，无效就直接抛异常
if (value <= 0) {
throw new IllegalArgumentException("值必须大于 0"); // 先验证
}
super(Long.toString(value)); // 验证通过再构造
}
}
优势：
- 参数无效时，父类不会被构造，节省资源
- 代码逻辑更清晰，验证在构造之前
- 更符合直觉
最佳实践
根据我的经验，用灵活构造函数体的时候，建议这么搞：
1. 优先用于参数验证
最常见的用法就是在调用父类构造函数之前验证参数：
public class ValidatedContainer extends BaseContainer {
public ValidatedContainer(int capacity, String name) {
// 先验证所有参数
if (capacity <= 0) {
throw new IllegalArgumentException("容量必须大于 0"); // 验证容量
}
if (name == null || name.trim().isEmpty()) {
throw new IllegalArgumentException("名字不能为空"); // 验证名字
}
super(capacity); // 验证通过再构造
}
}
2. 参数转换和计算
需要转换参数的时候，在前序里处理好：
public class SmartRange extends AbstractRange {
public SmartRange(int a, int b) {
// 计算实际的范围
int min = Math.min(a, b); // 计算最小值
int max = Math.max(a, b); // 计算最大值
// 验证范围
if (min < 0) {
throw new IllegalArgumentException("起始值不能为负"); // 验证最小值
}
super(min, max); // 传处理好的参数
}
}
3. 避免在前序里访问实例
记住前序里不能访问实例，所以字段初始化得放后序里：
public class Example extends Parent {
private String name;
private int count;
public Example(String name, int count) {
// 前序：只用局部变量
String processedName = processName(name); // 处理名字
int validatedCount = validateCount(count); // 验证计数
super(processedName); // 调用父类构造函数
// 后序：初始化字段
this.name = processedName; // 赋值给字段
this.count = validatedCount; // 赋值给字段
}
private static String processName(String name) {
return name != null ? name.trim() : "default"; // 静态方法处理名字
}
private static int validateCount(int count) {
if (count < 0) {
throw new IllegalArgumentException("计数不能为负"); // 验证计数
}
return count; // 返回验证后的值
}
}
4. 保持代码清晰
虽然前序可以写很多代码，但是别写太复杂，保持清晰：
public class Example extends Parent {
public Example(String input) {
// 前序：保持简单清晰
// 验证
if (input == null) {
throw new IllegalArgumentException("输入不能为空"); // 简单验证
}
// 转换
String processed = input.trim().toLowerCase(); // 简单转换
super(processed); // 调用父类构造函数
// 复杂的初始化逻辑放后序
initializeComplexStuff(); // 复杂逻辑放后面
}
}
总结
JEP 513 的灵活构造函数体是个挺实用的特性，让构造函数的写法更灵活，代码也更清晰。特别是那些需要参数验证、参数转换的场景，用这个特性写起来就舒服多了。
不过这个特性也有一些限制，前序里不能访问实例，所以字段初始化还是得放后序里。用的时候要注意这些限制，别写错了。
总的来说，这个特性让 Java 的构造函数更灵活了，特别是继承的场景下，能写出更清晰、更合理的代码。如果你还没试过，建议试试，特别是那些需要参数验证的构造函数，用灵活构造函数体能省不少事。
好了，今天就聊到这，有啥问题欢迎留言讨论。下次咱们聊聊 JEP 506，作用域值，用来替代 ThreadLocal 的，也是个挺有意思的特性。