Java继承类字段初始化问题：父类构造调用重写方法致字段未初始化

Java中存在明确的实例初始化时序：子类构造执行时会先调用父类构造，此时子类的实例字段（尤其是final修饰的字段）还未完成赋值。若父类构造中调用了被子类重写的方法，该方法访问子类未初始化的字段时会得到默认值（如null），引发逻辑错误。针对这个问题，以下是几种专业的解决方案：

方案1：移除基类构造中的可重写方法调用（推荐） #

遵循Java编码规范的核心原则——永远不要在构造器中调用可重写的方法。重构基类，将初始化逻辑从构造中剥离，改为由子类在字段初始化完成后显式触发。

重构后的基类：

public abstract class Entity {
    public Entity() {
        // 移除构造中的doSomething()调用
    }

    // 提供专门的初始化方法
    protected void initialize() {
        doSomething();
    }

    protected void doSomething() {
        // 基类默认逻辑
    }
}

子类实现：

public class Player extends Entity {
    private final String name;

    public Player(String name) {
        super();
        this.name = name;
        // 字段初始化完成后再调用初始化逻辑
        initialize();
    }

    @Override
    protected void doSomething() {
        super.doSomething();
        System.out.println("Name: " + name); // 可正常访问字段
    }
}

方案2：使用工厂方法替代构造器 #

通过工厂方法严格控制实例创建流程，确保字段完全初始化后再执行依赖字段的逻辑，避免构造链中的时序问题。

基类模板：

public abstract class Entity {
    protected Entity() {
        // 私有或受保护构造，避免直接实例化
    }

    protected abstract void doSomething();

    // 通用工厂方法
    public static <T extends Entity> T create(Supplier<T> supplier) {
        T instance = supplier.get();
        instance.doSomething();
        return instance;
    }
}

子类实现：

public class Player extends Entity {
    private final String name;

    // 私有构造，强制通过工厂方法创建实例
    private Player(String name) {
        super();
        this.name = name;
    }

    @Override
    protected void doSomething() {
        System.out.println("Name: " + name);
    }

    // 子类专属工厂方法
    public static Player createPlayer(String name) {
        return Entity.create(() -> new Player(name));
    }
}

使用方式：

Player player = Player.createPlayer("Alice");

方案3：将子类通用字段提升至基类（适合字段复用场景） #

如果多个子类都依赖相同类型的字段，可将字段移至基类，通过基类构造传入参数，确保基类构造调用方法时字段已完成初始化。

重构后的基类：

public abstract class Entity {
    protected final String name;

    public Entity(String name) {
        this.name = name;
        doSomething(); // 此时name已完成赋值
    }

    protected void doSomething() {
        System.out.println("Base Name: " + name);
    }
}

子类实现：

public class Player extends Entity {
    public Player(String name) {
        super(name); // 直接传递参数给父类构造
    }

    @Override
    protected void doSomething() {
        super.doSomething();
        System.out.println("Player Name: " + name); // 正常访问字段
    }
}

方案4：延迟初始化（备选方案，不推荐） #

若无法修改基类构造，可通过标记位延迟执行依赖字段的逻辑，确保第一次访问时字段已完成初始化。但该方式会增加代码复杂度，且存在线程安全风险，仅作为临时妥协方案。

示例：

public class Player extends Entity {
    private final String name;
    private boolean isInitialized = false;

    public Player(String name) {
        super();
        this.name = name;
        isInitialized = true;
    }

    @Override
    protected void doSomething() {
        super.doSomething();
        if (isInitialized) {
            System.out.println("Name: " + name);
        }
    }
}

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