Flexible Constructor Bodies：把校验放到 super() 之前

旧写法：校验只能塞进 super() 参数01

在 JDK 25 之前，构造器体必须以 super(...) 或 this(...) 开头。想在调用父构造器前校验参数，只能把逻辑塞进参数表达式或静态辅助方法，失败时的堆栈和可读性都不理想。

// 旧写法：校验藏在参数里
Employee(int age, String officeId) {
    super(validateAge(age), officeId);
    this.officeId = officeId;
}

static int validateAge(int age) {
    if (age < 18 || age > 67) {
        throw new IllegalArgumentException("age out of range");
    }
    return age;
}

JEP 513 把这部分语句称为构造器的 prologue：它在显式构造器调用之前执行，可以 fail fast，也可以先初始化本类字段。显式调用之后的代码是 epilogue。

// JDK 25：校验直接写在 super() 之前
Employee(int age, String officeId) {
    if (age < 18 || age > 67) {
        throw new IllegalArgumentException("age out of range");
    }
    super(age);
    this.officeId = officeId;
}

• prologue 可以包含局部变量、条件、try/catch、throw 等不依赖当前实例的语句。
• super(...) / this(...) 仍然必须恰好出现一次。
• prologue 执行完才调用父构造器；父构造器返回后才进入 epilogue。

早期构造上下文：能用什么，不能用什么02

prologue 和显式构造器调用的参数列表都属于早期构造上下文（early construction context）。代码不能使用正在构造的实例，只能使用参数、局部变量、静态成员，以及给本类未初始化的字段赋值。

class Base {
    Base(int x) {}
}

public class BeforeSuperRead extends Base {
    private int value;

    BeforeSuperRead(int x) {
        System.out.println(value); // 读字段
        super(x);
    }
}

BeforeSuperRead.java:9: error: cannot reference value before supertype constructor has been called
        System.out.println(value);
                           ^
1 error

class Base3 {
    Base3(int x) {}
}

public class BeforeSuperThis extends Base3 {
    BeforeSuperThis() {
        super(1);
    }

    BeforeSuperThis(int x) {
        consume(this); // 把 this 传出去
        super(x);
    }

    static void consume(BeforeSuperThis b) {}
}

BeforeSuperThis.java:11: error: cannot reference this before supertype constructor has been called
        consume(this);
                ^
1 error

在 super() 前初始化字段03

JEP 513 的另一个目标是把「字段初始化」提前：父构造器可能调用被子类覆写的方法，如果子类字段还没赋值，覆写方法会看到默认值。prologue 允许先给无初始化器 的字段赋值，再调用 super。

class Parent {
    Parent() {
        System.out.println("Parent body");
        hook();
    }

    void hook() {
        System.out.println("Parent hook");
    }
}

public class PrologueOrder extends Parent {
    private final String state;

    PrologueOrder() {
        state = "ready";
        System.out.println("Child prologue");
        super();
        System.out.println("Child epilogue, state=" + state);
    }

    @Override
    void hook() {
        System.out.println("Child hook, state=" + state);
    }

    public static void main(String[] args) {
        new PrologueOrder();
    }
}

Child prologue
Parent body
Child hook, state=ready
Child epilogue, state=ready

输出验证了两件事：子类 prologue 先于父构造器体执行；父构造器调用覆写方法时，state 已经是 ready。final 字段只要没有初始化器，也可以在 prologue 中赋值一次。

• 只能给本类声明的字段赋值；不能给父类字段赋值。
• 字段不能有初始化器；private int value = 7; 再在 prologue 赋值会编译失败。
• prologue 里的赋值是 single assignment 规则的一部分；不要重复赋值 final 字段。
• 不要在 prologue 里启动线程或注册回调，避免 this 逃逸。

this(...) 之前也可以校验04

this(...) 与 super(...) 一样可以出现在 prologue 之后。常见用法是重载构造器先做统一校验，再委托给主构造器，避免每个重载都重复检查。

class Base5 {
    Base5(int x) {
        System.out.println("Base5(" + x + ")");
    }
}

public class ThisDelegation extends Base5 {
    private final int value;

    ThisDelegation(int x) {
        if (x < 0) {
            throw new IllegalArgumentException("negative");
        }
        this(x, 1);
    }

    ThisDelegation(int x, int factor) {
        super(x * factor);
        this.value = x * factor;
    }

    public static void main(String[] args) {
        System.out.println("value=" + new ThisDelegation(5).value);
        try {
            new ThisDelegation(-1);
        } catch (IllegalArgumentException e) {
            System.out.println("rejected=" + e.getMessage());
        }
    }
}

Base5(5)
value=5
rejected=negative

• 校验放在委托构造器的 prologue，主构造器只负责赋值。
• this(...) 和 super(...) 不能同时出现在一个构造器体里。
• prologue 不能读取主构造器将要设置的字段；它只能使用参数和局部变量。
• 如果校验依赖父类状态，必须等 super 返回后在 epilogue 做。

常见坑与边界05

• 给有初始化器 的字段赋值：编译错误，不是运行期问题。
• 读字段 / 调实例方法：即使方法不访问字段，也不允许；编译器按语法上下文拒绝。
• 把 this 传给 lambda 或方法：同样属于引用当前实例，编译失败。
• 在 prologue 里 return：不允许；epilogue 里可以 return;，但不能 return value;。
• 以为父类字段已初始化：prologue 阶段父构造器还没运行，父类字段仍是默认值。
• record 的紧凑构造器：规则不同，不要直接把普通类的 prologue 经验套到 record。

class Base4 {
    Base4() {}
}

public class BeforeSuperInitialized extends Base4 {
    private int value = 7;

    BeforeSuperInitialized() {
        value = 9; // 字段有初始化器
        super();
    }
}

BeforeSuperInitialized.java:9: error: cannot assign initialized field 'value' before supertype constructor has been called
        value = 9;
        ^
1 error

版本边界BOUNDARY

这张表比 API 本身更值得记。写代码时先确认你的运行时版本。

费曼自检SELF CHECK

先合上页面，用自己的话回答，再展开对照。能讲出因果和反例，才算真正掌握。