建造者模式

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

概述[编辑 | 编辑源代码]

建造者模式的核心思想是将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。该模式通常包含以下几个角色：

Director（导演类）：负责调用具体建造者来构建产品的各个部分，并控制构建过程。
Builder（抽象建造者）：定义构建产品各个部件的抽象接口。
ConcreteBuilder（具体建造者）：实现Builder接口，构造和装配产品的各个部件。
Product（产品）：表示被构造的复杂对象。

建造者模式的主要优点包括：

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

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

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

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

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()

输出：

Computer parts: High-end CPU, 32GB RAM

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();
    }
}