Java建造者模式[编辑 | 编辑源代码]

建造者模式（Builder Pattern）是一种创建型设计模式，用于分步骤构建复杂对象。它允许用户通过指定对象的类型和内容来构建对象，而无需了解其内部的具体构造细节。该模式特别适用于需要多个步骤或可选参数来创建对象的场景。

介绍[编辑 | 编辑源代码]

建造者模式的主要目的是将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。它通常包括以下几个角色：

Director（指挥者）：负责调用具体建造者来构建对象。
Builder（抽象建造者）：定义构建对象的抽象步骤。
ConcreteBuilder（具体建造者）：实现抽象建造者的方法，提供具体的构建逻辑。
Product（产品）：最终构建的对象。

适用场景[编辑 | 编辑源代码]

当对象的构造过程需要多个步骤，并且这些步骤的顺序或内容可能变化时。
当需要创建的对象具有复杂的内部结构，或者包含多个可选参数时。
当希望对象的构造过程与表示分离，以提高代码的可读性和可维护性时。

代码示例[编辑 | 编辑源代码]

以下是一个简单的建造者模式实现示例，展示如何构建一个包含多个属性的`User`对象。

// 产品类
class User {
    private final String firstName;    // 必选参数
    private final String lastName;    // 必选参数
    private final int age;           // 可选参数
    private final String phone;       // 可选参数
    private final String address;     // 可选参数

    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
    }

    // 建造者类
    public static class UserBuilder {
        private final String firstName;
        private final String lastName;
        private int age;
        private String phone;
        private String address;

        public UserBuilder(String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        }

        public UserBuilder age(int age) {
            this.age = age;
            return this;
        }

        public UserBuilder phone(String phone) {
            this.phone = phone;
            return this;
        }

        public UserBuilder address(String address) {
            this.address = address;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }

    @Override
    public String toString() {
        return "User{" +
                "firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", age=" + age +
                ", phone='" + phone + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

// 客户端代码
public class BuilderPatternDemo {
    public static void main(String[] args) {
        User user = new User.UserBuilder("John", "Doe")
                .age(30)
                .phone("1234567890")
                .address("123 Main St")
                .build();

        System.out.println(user);
    }
}

输出[编辑 | 编辑源代码]

User{firstName='John', lastName='Doe', age=30, phone='1234567890', address='123 Main St'}

1. **`User`类**：表示最终构建的对象，包含必选和可选参数。 2. **`UserBuilder`类**：静态内部类，负责逐步设置`User`的属性，并最终调用`build()`方法返回完整的`User`对象。 3. **链式调用**：通过返回`this`，建造者支持链式调用，提高代码可读性。 4. **不可变性**：`User`类的属性被声明为`final`，确保对象一旦构建完成就无法修改。

实际案例[编辑 | 编辑源代码]

建造者模式在Java标准库中有广泛应用，例如：

`StringBuilder`和`StringBuffer`：用于逐步构建字符串。
`java.nio.file.Path`的`Path.of()`方法（间接使用建造者模式的思想）。
许多第三方库（如Lombok的`@Builder`注解）也利用建造者模式简化对象创建。

示例：`StringBuilder`[编辑 | 编辑源代码]

StringBuilder builder = new StringBuilder();
builder.append("Hello")
       .append(" ")
       .append("World!");
String result = builder.toString(); // "Hello World!"

类图[编辑 | 编辑源代码]

以下是用Mermaid绘制的建造者模式类图：

说明[编辑 | 编辑源代码]

**Director**：控制构建过程。
**Builder**：定义构建步骤的接口。
**ConcreteBuilder**：实现具体的构建逻辑。
**Product**：最终生成的对象。

优缺点[编辑 | 编辑源代码]

优点[编辑 | 编辑源代码]

**分离构造逻辑**：将对象的构造过程与表示分离。
**灵活构造**：支持逐步构造对象，并可调整构造步骤。
**提高可读性**：链式调用使代码更清晰。
**不可变对象**：适合构建不可变对象。

缺点[编辑 | 编辑源代码]

**代码冗余**：需要编写额外的建造者类。
**性能开销**：相比直接构造对象，建造者模式可能略微增加开销。

进阶应用[编辑 | 编辑源代码]

使用泛型优化建造者[编辑 | 编辑源代码]

可以通过泛型进一步优化建造者模式，使其支持不同类型的对象构建：

abstract class GenericBuilder<T> {
    protected T instance;

    protected abstract T createInstance();

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

    public T build() {
        return instance;
    }
}

class Person {
    private String name;
    private int age;

    // getters and setters
}

class PersonBuilder extends GenericBuilder<Person> {
    @Override
    protected Person createInstance() {
        return new Person();
    }

    public PersonBuilder name(String name) {
        instance.setName(name);
        return this;
    }

    public PersonBuilder age(int age) {
        instance.setAge(age);
        return this;
    }
}

与工厂模式对比[编辑 | 编辑源代码]

**工厂模式**：关注对象的整体创建，通常用于生成不同类型的对象。
**建造者模式**：关注对象的逐步构建，通常用于生成同一类型但配置不同的对象。

总结[编辑 | 编辑源代码]

建造者模式是一种强大的设计模式，特别适用于需要分步骤构造复杂对象的场景。它通过分离构造逻辑和表示，提高了代码的可读性和可维护性。尽管需要额外编写建造者类，但其灵活性和清晰性使其成为Java开发中的重要工具。