编辑“︁建造者模式”︁

{{DISPLAYTITLE:建造者模式}}

'''建造者模式'''（Builder Pattern）是一种[[创建型设计模式]]，用于分步骤构建复杂对象。它允许用户通过指定对象的类型和内容来构建对象，而无需了解对象的具体构建细节。建造者模式特别适用于需要生成具有复杂内部结构的对象，或需要将对象的构造过程与表示分离的场景。

== 概述 ==
建造者模式的核心思想是将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。该模式通常包含以下几个角色：
* '''Director'''（导演类）：负责调用具体建造者来构建产品的各个部分，并控制构建过程。
* '''Builder'''（抽象建造者）：定义构建产品各个部件的抽象接口。
* '''ConcreteBuilder'''（具体建造者）：实现Builder接口，构造和装配产品的各个部件。
* '''Product'''（产品）：表示被构造的复杂对象。

建造者模式的主要优点包括：
* 封装性好，构建和表示分离。
* 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
* 便于控制细节风险，可以精细控制产品的创建过程。

== 结构 ==
<mermaid>
classDiagram
    class Director {
        +Construct()
    }
    class Builder {
        <<interface>>
        +BuildPartA()
        +BuildPartB()
        +GetResult()
    }
    class ConcreteBuilder {
        +BuildPartA()
        +BuildPartB()
        +GetResult()
    }
    class Product

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

== 代码示例 ==
以下是一个简单的建造者模式实现示例，展示如何构建一个包含多个部件的产品。

=== Python 示例 ===
<syntaxhighlight lang="python">
from abc import ABC, abstractmethod

# 产品类
class Computer:
    def __init__(self):
        self.parts = []

    def add_part(self, part):
        self.parts.append(part)

    def show_parts(self):
        print("Computer parts:", ", ".join(self.parts))

# 抽象建造者
class ComputerBuilder(ABC):
    @abstractmethod
    def build_cpu(self):
        pass

    @abstractmethod
    def build_ram(self):
        pass

    @abstractmethod
    def get_computer(self):
        pass

# 具体建造者
class GamingComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.computer = Computer()

    def build_cpu(self):
        self.computer.add_part("High-end CPU")

    def build_ram(self):
        self.computer.add_part("32GB RAM")

    def get_computer(self):
        return self.computer

# 导演类
class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct_computer(self):
        self.builder.build_cpu()
        self.builder.build_ram()

# 客户端代码
if __name__ == "__main__":
    builder = GamingComputerBuilder()
    director = Director(builder)
    director.construct_computer()
    computer = builder.get_computer()
    computer.show_parts()
</syntaxhighlight>

'''输出：'''
<pre>
Computer parts: High-end CPU, 32GB RAM
</pre>

=== Java 示例 ===
<syntaxhighlight lang="java">
// 产品类
class Computer {
    private List<String> parts = new ArrayList<>();

    public void addPart(String part) {
        parts.add(part);
    }

    public void showParts() {
        System.out.println("Computer parts: " + String.join(", ", parts));
    }
}

// 抽象建造者
interface ComputerBuilder {
    void buildCPU();
    void buildRAM();
    Computer getComputer();
}

// 具体建造者
class GamingComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    public void buildCPU() {
        computer.addPart("High-end CPU");
    }

    public void buildRAM() {
        computer.addPart("32GB RAM");
    }

    public Computer getComputer() {
        return computer;
    }
}

// 导演类
class Director {
    private ComputerBuilder builder;

    public Director(ComputerBuilder builder) {
        this.builder = builder;
    }

    public void constructComputer() {
        builder.buildCPU();
        builder.buildRAM();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        ComputerBuilder builder = new GamingComputerBuilder();
        Director director = new Director(builder);
        director.constructComputer();
        Computer computer = builder.getComputer();
        computer.showParts();
    }
}
</syntaxhighlight>

'''输出：'''
<pre>
Computer parts: High-end CPU, 32GB RAM
</pre>

== 实际应用场景 ==
建造者模式在以下场景中特别有用：

1. '''复杂对象的创建'''：当需要创建的对象具有复杂的内部结构，且需要分步骤构建时。
2. '''构造过程需要不同的表示'''：当构造过程需要创建对象的不同表示时。
3. '''避免"重叠构造函数"问题'''：当类的构造函数参数过多，导致代码难以阅读和维护时。

=== 真实案例 ===
* '''StringBuilder'''（Java/.NET等语言中的字符串构建器）就是建造者模式的一个经典实现。
* '''文档转换器'''：如将HTML文档转换为PDF或Word文档时，可以使用建造者模式分步骤构建目标文档。
* '''UI组件构建'''：在图形用户界面库中，复杂UI组件的构建通常采用建造者模式。

== 变体与相关模式 ==
* '''链式调用建造者'''：通过方法链（Method Chaining）实现更流畅的接口，也称为''流畅接口''模式。
* '''与工厂模式比较'''：工厂模式关注的是整体对象的创建，而建造者模式关注的是分步骤构建复杂对象。
* '''与组合模式'''：建造者模式常被用来构建组合结构。

== 数学表示 ==
建造者模式可以形式化表示为：
<math>
Product = Director(ConcreteBuilder)
</math>
其中：
* <math>Director</math> 控制构建过程
* <math>ConcreteBuilder</math> 实现具体的构建步骤
* <math>Product</math> 是最终构建的对象

== 最佳实践 ==
* 当产品的构建过程复杂且需要分步骤进行时，考虑使用建造者模式。
* 如果产品的构建过程只有一种方式，可以考虑省略Director角色，让客户端直接使用Builder。
* 使用流畅接口（Fluent Interface）可以使得建造者模式的使用更加直观。

== 局限性 ==
* 由于需要创建多个ConcreteBuilder类，因此会增加系统的复杂性。
* 产品之间的差异较大时，建造者模式可能不太适用。
* 如果产品的内部结构发生变化，可能需要修改多个建造者类。

== 总结 ==
建造者模式是一种强大的创建型设计模式，特别适用于需要分步骤构建复杂对象的场景。通过将对象的构建与表示分离，它提供了更好的灵活性和可维护性。理解并正确应用建造者模式可以帮助开发者创建更清晰、更可维护的代码结构。

[[Category:计算机科学]]
[[Category:面试技巧]]
[[Category:设计模式]]