Java：多级继承的跨包独立Builder类构建需求

我来帮你落地这个需求——打造一套和待构建类分属不同包、完全独立的多级继承Builder体系，同时给实体类加上setter方法供Builder调用。下面是完整的可运行实现方案：

包结构规划 #

我们把代码分成两个独立包，彻底解耦Builder和实体类：

• com.example.domain：存放待构建的实体类（带public setter）
• com.example.builders：存放独立的Builder类

第一步：编写domain包的实体类（带Setter） #

先定义基类Person和子类Employee，都提供public setter方法，让跨包的Builder可以访问：

com.example.domain.Person

package com.example.domain;

public class Person {
    private String name;
    private int age;

    // 空参构造，供Builder实例化对象
    public Person() {}

    // Public setter，允许跨包的Builder调用
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 可选：Getter用于验证构建结果
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

com.example.domain.Employee（继承Person）

package com.example.domain;

public class Employee extends Person {
    private String employeeId;
    private String department;

    public Employee() {}

    // 子类属性的Public setter
    public void setEmployeeId(String employeeId) {
        this.employeeId = employeeId;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    // 可选：Getter
    public String getEmployeeId() {
        return employeeId;
    }

    public String getDepartment() {
        return department;
    }
}

第二步：编写builders包的多级继承Builder类 #

这里用泛型自引用的技巧解决Builder继承后的链式调用问题，确保子类Builder能无缝调用父类的构建方法：

com.example.builders.PersonBuilder（基类Builder）

package com.example.builders;

import com.example.domain.Person;

// 泛型说明：
// T = 最终构建的实体类型
// SELF = Builder自身类型（保证链式调用返回正确的子类Builder）
public class PersonBuilder<T extends Person, SELF extends PersonBuilder<T, SELF>> {
    protected T entity;

    // 构造方法接收具体的实体实例（子类Builder会传入子类实体）
    public PersonBuilder(T entity) {
        this.entity = entity;
    }

    // 链式设置父类属性，返回SELF类型
    public SELF name(String name) {
        entity.setName(name);
        return self();
    }

    public SELF age(int age) {
        entity.setAge(age);
        return self();
    }

    // 最终构建方法，返回实体对象
    public T build() {
        return entity;
    }

    // 子类需重写此方法，返回自身类型
    protected SELF self() {
        return (SELF) this;
    }
}

com.example.builders.EmployeeBuilder（子类Builder）

package com.example.builders;

import com.example.domain.Employee;

// 指定泛型参数：T=Employee，SELF=EmployeeBuilder
public class EmployeeBuilder extends PersonBuilder<Employee, EmployeeBuilder> {

    // 构造方法实例化Employee，传给父类Builder
    public EmployeeBuilder() {
        super(new Employee());
    }

    // 链式设置子类专属属性
    public EmployeeBuilder employeeId(String employeeId) {
        entity.setEmployeeId(employeeId);
        return self();
    }

    public EmployeeBuilder department(String department) {
        entity.setDepartment(department);
        return self();
    }

    // 重写self方法，明确返回当前Builder类型
    @Override
    protected EmployeeBuilder self() {
        return this;
    }
}

第三步：使用示例 #

现在可以轻松实现链式构建，不管是父类还是子类实体都能流畅调用：

public class Main {
    public static void main(String[] args) {
        // 构建Person实例
        Person person = new PersonBuilder<>(new Person())
                .name("Alice")
                .age(30)
                .build();

        // 构建Employee实例，同时调用父类+子类的构建方法
        Employee employee = new EmployeeBuilder()
                .name("Bob")
                .age(28)
                .employeeId("EMP001")
                .department("Engineering")
                .build();

        // 验证结果
        System.out.println(employee.getName()); // 输出: Bob
        System.out.println(employee.getEmployeeId()); // 输出: EMP001
    }
}

核心设计要点 #

• 跨包解耦：实体类和Builder分属不同包，实体类只需要提供public setter，无需依赖任何Builder代码。
• 泛型自引用：通过SELF泛型参数解决了Builder继承后链式调用的类型丢失问题，确保调用父类方法后仍能返回子类Builder。
• 多级继承支持：子类Builder自动继承父类的所有属性设置方法，同时可以扩展自身的专属方法，完美适配实体类的继承体系。

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