编辑“︁Java建造者模式”︁（章节）

= Java建造者模式 =

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

== 介绍 ==

建造者模式的主要目的是将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。它通常包括以下几个角色：
* '''Director'''（指挥者）：负责调用具体建造者来构建对象。
* '''Builder'''（抽象建造者）：定义构建对象的抽象步骤。
* '''ConcreteBuilder'''（具体建造者）：实现抽象建造者的方法，提供具体的构建逻辑。
* '''Product'''（产品）：最终构建的对象。

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

== 代码示例 ==

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

<syntaxhighlight lang="java">
// 产品类
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);
    }
}
</syntaxhighlight>

=== 输出 ===
<pre>
User{firstName='John', lastName='Doe', age=30, phone='1234567890', address='123 Main St'}
</pre>

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

== 实际案例 ==

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

=== 示例：`StringBuilder` ===
<syntaxhighlight lang="java">
StringBuilder builder = new StringBuilder();
builder.append("Hello")
       .append(" ")
       .append("World!");
String result = builder.toString(); // "Hello World!"
</syntaxhighlight>

== 类图 ==

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

<mermaid>
classDiagram
    class Director {
        +construct()
    }
    class Builder {
        <<interface>>
        +buildPartA()
        +buildPartB()
        +getResult()
    }
    class ConcreteBuilder {
        +buildPartA()
        +buildPartB()
        +getResult()
    }
    class Product

    Director --> Builder
    Builder <|-- ConcreteBuilder
    ConcreteBuilder --> Product
</mermaid>

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

== 优缺点 ==

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

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

== 进阶应用 ==

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

<syntaxhighlight lang="java">
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;
    }
}
</syntaxhighlight>

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

== 总结 ==

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

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java设计模式]]