Java 25 flexible constructor bodies 怎样在 super 前准备参数

Java 25 的 flexible constructor bodies 解决了一个很具体的构造器问题：子类在调用 super(...) 前，需要先校验参数、计算派生值，或者把当前类的关键字段准备好。现在这些语句可以写在显式构造器调用之前，但这段区域仍然不能随意访问正在创建的实例。

官方资料：https://docs.oracle.com/en/java/javase/25/language/flexible-constructor-bodies.html

JEP：https://openjdk.org/jeps/513

实用记法是：先用参数、局部变量和静态能力准备输入；如果父类构造期间可能调用子类重写方法，再用赋值语句初始化当前类字段，最后调用 super(...)。读取当前实例的字段或调用实例方法仍要等到显式构造器调用之后。

先看 super 前为什么需要准备数据

旧的构造器写法通常把 super(...) 放在第一行。这样做本身没有问题，但父类构造器可能调用一个会被子类重写的方法。此时子类字段还没有准备好，重写方法看到的可能是 0、false 或 null。

class BaseName {
    BaseName(String value) {
        // 说明：父类构造期间调用可被子类重写的方法。
        printName();
    }

    void printName() {
        System.out.println("base");
    }
}

class UserName extends BaseName {
    private final String normalized;

    UserName(String input) {
        // 旧写法无法在 super 前完成校验和字段准备。
        super(input);
        this.normalized = input.trim();
    }

    @Override
    void printName() {
        System.out.println(normalized);
    }
}

这里的问题不是父类一定不该调用可重写方法，而是子类构造器没有机会在父类构造前建立必要状态。Java 25 允许把这段准备工作放进构造器的 prologue，也就是显式 super(...) 或 this(...) 之前的语句区域。

用局部变量完成校验和派生

最稳妥的第一步是只使用构造器参数、局部变量和静态方法。它们不依赖当前实例，因此适合放在 super(...) 前。参数校验失败时直接抛出异常，也不会创建一个状态不完整的父类对象。

class PositiveName extends BaseName {
    private final String normalized;

    PositiveName(String input) {
        // 说明：局部变量和静态方法不需要读取正在创建的实例。
        String value = java.util.Objects.requireNonNull(input, "input").trim();
        if (value.isEmpty()) {
            throw new IllegalArgumentException("name must not be empty");
        }

        // 说明：先保存字段，再把同一个派生值交给父类构造器。
        this.normalized = value;
        super(value);
    }

    @Override
    void printName() {
        // 说明：父类构造期间调用这里时，字段已经完成赋值。
        System.out.println(normalized);
    }
}

这个例子只围绕一个派生值展开：value 来自入参，trim() 是参数对象的操作，Objects.requireNonNull 是静态方法调用。真正需要避免的是通过 this 去调用实例方法，或者在赋值之外读取当前类字段。

必要时先初始化当前类字段

Java 25 的规则不只允许准备传给父类的参数，也允许在 super(...) 前给当前类字段赋值。适合的场景是父类构造器可能触发子类重写方法，而该方法需要读取一个已经由构造参数决定的字段。

class SafeUserName extends BaseName {
    private final String normalized;

    SafeUserName(String input) {
        // 说明：先在局部变量中完成所有依赖入参的计算和校验。
        String value = java.util.Objects.requireNonNull(input, "input").trim();
        if (value.isEmpty()) {
            throw new IllegalArgumentException("name must not be empty");
        }

        // 说明：允许给当前类字段赋值，但不能在这里读取它或调用实例方法。
        this.normalized = value;
        super(value);
    }

    @Override
    void printName() {
        // 说明：该方法在构造器前置区域结束后才由父类构造流程触发。
        System.out.println("name=" + normalized);
    }
}

字段赋值要放在读取之前理解：this.normalized = value 是允许的初始化动作，但 if (this.normalized.isEmpty()) 属于读取当前实例，不能放在 super(...) 前。把校验保留在局部变量上，边界最清楚。

划清早期构造上下文的访问边界

super(...) 前的代码处在 early construction context。它的目标是准备构造器调用，而不是把完整的当前对象当成已经可用的实例。可以把规则分成三组：

class ConfiguredChild extends BaseName {
    private final String value;

    ConfiguredChild(String input, java.util.Locale locale) {
        // 说明：独立参数对象可以参与计算，但不要通过 this 访问当前实例。
        String prepared = input.toLowerCase(locale).trim();
        this.value = prepared;
        super(prepared);
    }

    @Override
    void printName() {
        System.out.println(value);
    }
}

处理 this(...)、记录类与编译版本

这项规则同样覆盖显式的 this(...)。如果一个重载构造器需要先从输入对象拆出两个值并校验，可以在调用本类另一个构造器前完成这些动作。不过 record 的规范构造器不能调用 super(...)；record 的非规范构造器需要通过 this(...) 进入规范构造器，因此不要把普通类的继承示例直接套到 record 上。

class Endpoint extends BaseName {
    Endpoint(String host, int port) {
        super(host + ":" + port);
    }

    Endpoint(java.net.URI uri) {
        // 说明：先从外部参数对象提取值，再委托给同类构造器。
        String host = java.util.Objects.requireNonNull(uri, "uri").getHost();
        int port = uri.getPort() == -1 ? 443 : uri.getPort();
        if (host == null || host.isBlank()) {
            throw new IllegalArgumentException("uri host is empty");
        }
        this(host, port);
    }
}

Java 25 中这项能力已经是永久语言特性，使用 JDK 25 编译时不需要为它添加 --enable-preview。可以用下面的命令确认项目确实按 Java 25 语言级别编译：

# 使用 Java 25 的语言级别编译示例文件
javac --release 25 Endpoint.java

如果项目仍在 JDK 24 或更早版本上，语法和命令行要以对应版本的预览规则为准；不要把旧版本的 preview 开关当成 Java 25 的必选项。

把排查结论收束成一张清单

1. 父类构造器是否会调用可被子类重写的方法？如果会，先确认重写方法依赖哪些字段。
2. 字段需要的值能否仅由构造器参数、局部变量或静态方法计算？优先采用这种方式。
3. 如果父类构造期间必须读取子类字段，只做直接字段赋值，不要在 super(...) 前读取它。
4. 把当前实例方法、实例字段读取和 super 成员访问全部移到显式构造器调用之后。
5. 涉及 this(...) 或 record 时，重新确认构造器类型，不要套用普通子类的 super(...) 规则。

这样使用 flexible constructor bodies，重点不是把更多语句塞到 super(...) 前，而是把“输入准备”和“实例使用”明确分开：前者服务于父类构造器参数与必要字段初始化，后者等构造器调用完成后再进行。

相关问题

Java 25 的 flexible constructor bodies 还是预览特性吗？

不是。Java SE 25 将它作为永久语言特性发布；文章示例按 Java 25 语言级别书写。

super 前能不能调用 this.someMethod()？

不能。即使方法看起来只做字符串处理，它仍然是当前实例方法。把逻辑改为静态方法，或在局部变量上计算。

为什么字段可以赋值，却不能读取？

这项设计允许子类在父类构造期间先建立必要状态，但不把当前实例视为已经完成初始化。读取字段、调用实例方法仍可能观察到不完整对象，因此被限制。