Java中如何在父类构造器使用子类赋值的属性且保留b为final

Java的实例初始化存在硬性约束，没有办法绕过调整：

• 对象创建时的执行顺序固定为：先为所有实例字段分配内存并赋默认零值 → 从上到下执行父类的字段赋值逻辑、实例代码块 → 执行父类构造器主体 → 执行子类的字段赋值逻辑、实例代码块 → 执行子类构造器主体。
• 语法层面强制要求super()必须放在子类构造器的第一行，本质就是对齐上述初始化顺序，不存在语法手段可以把子类的赋值逻辑挪到父类初始化之前执行。
• 你提供的示例代码本身存在编译问题：父类的a是private修饰的私有成员，子类没有直接访问权限，无法在子类构造器中直接给a赋值。

方案1：通过父类带参构造器传递a值（无坑首选） #

这个方案完全满足约束：b保持final修饰、b的计算逻辑完全保留在父类内部、不需要子类干预b的赋值，不存在语法冲突。
实现代码：

abstract class Parent {
    // a也可设为final，避免后续被随意修改
    private final int a;
    // b保持final修饰
    private final int b;

    // 父类暴露受保护的带参构造器，接收子类传入的a值
    protected Parent(int a) {
        this.a = a;
        // 依赖a的b值，直接在父类构造器内计算赋值，逻辑完全留在父类
        this.b = a + 1;
    }
}

class Child extends Parent {
    public Child() {
        // 把需要传给父类的a值作为super()的入参传递，满足super()在第一行的语法要求
        super(2);
    }
}

方案优势：

• 封装性完整，所有和b相关的计算逻辑都在父类内部完成，子类只需要传递a的实际值即可，不需要感知b的存在。
• 所有字段都可保持final修饰，符合不可变对象的设计要求，不存在隐式的初始化顺序bug。

方案2：用静态工厂方法封装前置计算逻辑 #

如果a的计算逻辑比较复杂，不适合直接写在super()的参数表达式里，可以用静态工厂方法替代公开的构造器，把a的计算逻辑挪到工厂方法里：

class Child extends Parent {
    // 构造器改为私有，禁止外部直接实例化
    private Child(int a) {
        super(a);
    }

    // 对外暴露的实例创建入口，在这里可以自由编写a的计算逻辑
    public static Child create() {
        // 这里可以写任意复杂的业务逻辑计算a，没有语法限制
        int a = calculateAFromBiz();
        return new Child(a);
    }

    private static int calculateAFromBiz() {
        return 2;
    }
}

这个方案和带参构造的本质逻辑完全一致，只是解决了复杂计算式直接写在super参数里可读性差的问题。

方案3：模板方法模式（谨慎使用） #

如果不想给父类增加带参构造器，可以把a的获取逻辑做成父类的抽象方法，由子类实现，再在父类构造器中调用获取a值计算b。

注意：这个方案存在严格的适用边界——父类构造器执行时，子类的实例字段还没有完成初始化赋值，如果子类的a值依赖自身的实例字段（即需要通过构造器传参存储的值），调用抽象方法拿到的a值会是默认的0，产生难以排查的隐式bug。该方案仅适用于子类返回的a值是常量、不依赖子类实例状态的场景。
实现代码：

abstract class Parent {
    private final int b;

    // 定义抽象方法，强制子类提供a的获取逻辑
    protected abstract int getA();

    protected Parent() {
        // 调用子类实现的方法获取a，计算b
        this.b = getA() + 1;
    }
}

// 示例子类：a为固定常量，不依赖自身实例字段，不会出现顺序问题
class ConstantChild extends Parent {
    @Override
    protected int getA() {
        return 2;
    }
}

内容的提问来源于stack exchange，提问作者Badda