子类构造函数参数问题：通过ClassBC传递父类字段遇阻

我之前处理过不少类似的Builder模式踩坑场景，你的问题核心其实是混淆了Builder的使用方式和父类初始化的逻辑——算不上违反编程语言的语法规则，但确实违背了对象初始化的依赖顺序原则，以及Builder模式的常见设计规范，这才导致编译通过但运行失败。

先帮你还原下大概率的代码结构（方便咱们对齐问题）：

class ClassBC {
    private String b;
    private String c;
    // 构造方法、getter省略
}

class Parent {
    protected String b;
    protected String c;

    public static class Builder {
        private String b;
        private String c;

        public Builder b(String b) { this.b = b; return this; }
        public Builder c(String c) { this.c = c; return this; }
        
        public Parent build() {
            Parent p = new Parent();
            p.b = this.b;
            p.c = this.c;
            return p;
        }
    }
}

class Child extends Parent {
    private ClassBC bc;

    public Child(ClassBC bc) {
        this.bc = bc;
        // 你大概是在这里调用了Parent的Builder
        new Parent.Builder().b(bc.getB()).c(bc.getC()).build();
    }
}

为什么运行会失败？ #

你这里犯了一个关键错误：调用Parent.Builder.build()时，创建了一个全新的Parent实例，而不是给当前Child实例的父类部分赋值。也就是说，当前Child对象的b、c字段根本没被初始化，你只是额外创建了一个无关的Parent对象，自然会导致后续使用父类字段时出问题。

这违反规则了吗？ #

严格来说，没有违反Java（假设你用的是Java）的语法规则——编译器允许你在子类构造中创建其他对象。但它违反了两个重要的设计/初始化原则：

• 父类初始化顺序原则：子类构造时，必须先通过super()（显式或隐式）完成父类部分的初始化，而不是创建独立的父类实例。
• Builder模式的设计意图：Parent的Builder是用来创建Parent（或其子类）实例的，不是用来在已有实例上赋值字段的，你误用了Builder的场景。

正确的解决方案 #

这里给你两种常用的修复方式，根据你的需求选就行：

方案1：让Parent的Builder支持子类构建（推荐，保留Builder模式）

调整Parent的Builder为泛型，允许子类扩展并复用父类的字段赋值逻辑：

class Parent {
    protected String b;
    protected String c;

    // 用protected构造，仅允许子类调用
    protected Parent() {}

    // 泛型Builder，支持子类实例构建
    public static class Builder<T extends Parent> {
        protected String b;
        protected String c;

        public Builder<T> b(String b) { this.b = b; return this; }
        public Builder<T> c(String c) { this.c = c; return this; }

        // 子类可以重写这个方法，创建自己的实例
        protected T createInstance() {
            return (T) new Parent();
        }

        public T build() {
            T instance = createInstance();
            instance.b = this.b;
            instance.c = this.c;
            return instance;
        }
    }
}

class Child extends Parent {
    private ClassBC bc;

    // private构造，仅让Child的Builder调用
    private Child(ClassBC bc) {
        this.bc = bc;
    }

    // Child专属的Builder，复用Parent的逻辑
    public static class Builder extends Parent.Builder<Child> {
        private ClassBC bc;

        public Builder bc(ClassBC bc) { this.bc = bc; return this; }

        @Override
        protected Child createInstance() {
            return new Child(bc);
        }

        @Override
        public Child build() {
            // 先从ClassBC中取出b、c，设置到父类Builder里
            super.b(bc.getB()).c(bc.getC());
            return super.build();
        }
    }
}

使用的时候就这么调用：

ClassBC bc = new ClassBC("bValue", "cValue");
Child child = new Child.Builder().bc(bc).build();

这样既正确初始化了父类的b、c字段，又保留了Builder模式的灵活性。

方案2：直接用父类带参构造（简单直接，不需要Builder的场景）

如果你的场景不需要Builder模式，直接给Parent加一个带参构造，子类构造时先调用super()初始化父类字段：

class Parent {
    protected String b;
    protected String c;

    public Parent(String b, String c) {
        this.b = b;
        this.c = c;
    }
}

class Child extends Parent {
    private ClassBC bc;

    public Child(ClassBC bc) {
        // 先初始化父类部分，再赋值子类自己的字段
        super(bc.getB(), bc.getC());
        this.bc = bc;
    }
}

这种写法更简洁，适合不需要链式调用、字段不多的场景。

总结 #

你的问题本质是误用Builder模式导致父类字段没有被正确初始化到当前子类实例，而非违反语法规则。调整Builder的设计逻辑，或者改用父类带参构造，就能解决这个问题。

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