封装和抽象 Java 的构建者模式

创建一个通用的 Builder 接口或抽象类，并将具体的构建过程委托给子类或具体实现类。这样做可以复用构建逻辑，并且提高代码的可扩展性和维护性。

1. 抽象 Builder 类

首先，我们可以定义一个抽象的 Builder 类，这个类会定义一个通用的构建流程，并且要求子类去实现具体的构建步骤。

public abstract class Builder<T> {
    protected T instance;

    // 提供创建对象的通用方法
    protected abstract T createInstance();

    // 每个具体的构建步骤由子类实现
    public Builder<T> with(Consumer<T> setter) {
        setter.accept(instance);
        return this;
    }

    // 返回最终构建的对象
    public T build() {
        return instance;
    }
}

2. 具体实现 UserBuilder

继承上面的抽象 Builder 类，针对具体的 User 对象，我们可以实现一个 UserBuilder：

public class User {
    private String firstName;
    private String lastName;
    private int age;
    private String phone;
    private String address;

    // 公开构造函数或私有构造函数
    public User() {
    }

    // getter和setter
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getAge() {
        return age;
    }

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

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

public class UserBuilder extends Builder<User> {

    @Override
    protected User createInstance() {
        return new User();
    }

    public UserBuilder() {
        this.instance = createInstance();
    }

    public UserBuilder firstName(String firstName) {
        return this.with(user -> user.setFirstName(firstName));
    }

    public UserBuilder lastName(String lastName) {
        return this.with(user -> user.setLastName(lastName));
    }

    public UserBuilder age(int age) {
        return this.with(user -> user.setAge(age));
    }

    public UserBuilder phone(String phone) {
        return this.with(user -> user.setPhone(phone));
    }

    public UserBuilder address(String address) {
        return this.with(user -> user.setAddress(address));
    }
}

3. 使用方式

使用抽象后的 Builder 类构建 User 对象：

public class Main {
    public static void main(String[] args) {
        User user = new UserBuilder()
                .firstName("John")
                .lastName("Doe")
                .age(30)
                .phone("123456789")
                .address("123 Main St")
                .build();

        System.out.println(user.getFirstName());
        System.out.println(user.getLastName());
        System.out.println(user.getAge());
        System.out.println(user.getPhone());
        System.out.println(user.getAddress());
    }
}

4. 优势

通过这种方式：

• 通用性：Builder 类可以复用，也可以通过创建不同的具体构建器（如 UserBuilder）来构建不同的对象。
• 可扩展性：如果以后有其他复杂对象需要使用构建者模式，只需要继承 Builder 类，提供具体的实现即可。
• 简化构建流程：with 方法的引入使得构建过程更加简洁和灵活。

这个模式让你的代码不仅易于维护，而且能很好地应对未来的扩展需求。