建造者模式（Builder Pattern）深入解析：提升复杂对象构建的灵活性_如果没有指挥者类director,客户端将如何构建复杂产品-优快云博客

本文链接：https://blog.youkuaiyun.com/sjdgehi/article/details/145871498

建造者模式（Builder Pattern）深入解析：提升复杂对象构建的灵活性

在面向对象编程中，经常会遇到需要构建复杂对象的情况，尤其是当这些对象的构建过程涉及到多个步骤或参数时，传统的构造函数或工厂方法往往显得不够灵活和可扩展。此时，**建造者模式（Builder Pattern）**作为一种创建型设计模式，能够有效地简化复杂对象的构建过程。

本文将围绕建造者模式这一主题进行深入讲解，分析其原理、实现方法以及应用场景，并通过具体代码示例帮助你更好地理解和掌握这一模式。

1. 什么是建造者模式？

建造者模式是一种创建型设计模式，旨在将一个复杂对象的构建与其表示分离。使用建造者模式时，客户端通过一个指挥者对象（Director）来构建复杂对象，而复杂对象的具体创建过程则交给不同的建造者对象（Builder）来完成。

1.1 建造者模式的结构

在建造者模式中，主要包含以下几个角色：

产品（Product）：最终构建出来的复杂对象。
抽象建造者（Builder）：定义了构建产品各个部件的接口。
具体建造者（Concrete Builder）：实现了抽象建造者接口，构建具体的产品对象。
指挥者（Director）：负责按照指定的顺序调用建造者对象的方法来构建产品。
客户端（Client）：通过指挥者来构建产品对象，关注最终的产品，而不关心建造过程。

1.2 UML类图

建造者模式的UML类图通常如下所示：

    +--------------------+           +---------------------+
    |      Product       |<--------->|     Builder         |
    +--------------------+           +---------------------+
    |  Part1             |           | + buildPart1()      |
    |  Part2             |           | + buildPart2()      |
    |  Part3             |           | + buildPart3()      |
    +--------------------+           +---------------------+
            ^                            ^                     ^
            |                            |                     |
    +---------------------+       +--------------------+     +--------------------+
    | ConcreteBuilder1    |       | ConcreteBuilder2   |     | Director           |
    +---------------------+       +--------------------+     +--------------------+
    | + buildPart1()      |       | + buildPart1()     |     | + construct()      |
    | + buildPart2()      |       | + buildPart2()     |     |                    |
    | + buildPart3()      |       | + buildPart3()     |     +--------------------+
    +---------------------+

Product：表示最终构建的复杂对象。
Builder：声明了构建产品各个部件的方法。
ConcreteBuilder：实现了构建部件的具体方法。
Director：根据需求安排构建步骤。
Client：通过Director来构建产品。

2. 建造者模式的实现

接下来，我们通过代码示例来深入了解建造者模式。

2.1 定义产品（Product）

我们将构建一个Computer（电脑）类，它包含多个部件，如CPU、内存、硬盘和显卡。

// 产品类
public class Computer {
    private String CPU;
    private String RAM;
    private String HDD;
    private String GPU;

    // Getter和Setter方法
    public void setCPU(String CPU) {
        this.CPU = CPU;
    }

    public void setRAM(String RAM) {
        this.RAM = RAM;
    }

    public void setHDD(String HDD) {
        this.HDD = HDD;
    }

    public void setGPU(String GPU) {
        this.GPU = GPU;
    }

    @Override
    public String toString() {
        return "Computer [CPU=" + CPU + ", RAM=" + RAM + ", HDD=" + HDD + ", GPU=" + GPU + "]";
    }
}

2.2 定义抽象建造者（Builder）

接下来，我们定义一个抽象建造者接口，声明构建各个部件的方法。

// 抽象建造者接口
public interface ComputerBuilder {
    void buildCPU();
    void buildRAM();
    void buildHDD();
    void buildGPU();
    Computer getComputer();
}

2.3 定义具体建造者（ConcreteBuilder）

然后，我们为不同的电脑配置实现具体的建造者：

// 具体建造者 1：高配电脑
public class HighEndComputerBuilder implements ComputerBuilder {
    private Computer computer;

    public HighEndComputerBuilder() {
        this.computer = new Computer();
    }

    @Override
    public void buildCPU() {
        computer.setCPU("Intel i9");
    }

    @Override
    public void buildRAM() {
        computer.setRAM("32GB");
    }

    @Override
    public void buildHDD() {
        computer.setHDD("1TB SSD");
    }

    @Override
    public void buildGPU() {
        computer.setGPU("NVIDIA RTX 3090");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

// 具体建造者 2：低配电脑
public class LowEndComputerBuilder implements ComputerBuilder {
    private Computer computer;

    public LowEndComputerBuilder() {
        this.computer = new Computer();
    }

    @Override
    public void buildCPU() {
        computer.setCPU("Intel i3");
    }

    @Override
    public void buildRAM() {
        computer.setRAM("8GB");
    }

    @Override
    public void buildHDD() {
        computer.setHDD("500GB HDD");
    }

    @Override
    public void buildGPU() {
        computer.setGPU("Integrated Graphics");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

2.4 定义指挥者（Director）

指挥者类负责按照特定顺序指挥建造者来构建产品。

// 指挥者
public class Director {
    private ComputerBuilder builder;

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

    public Computer construct() {
        builder.buildCPU();
        builder.buildRAM();
        builder.buildHDD();
        builder.buildGPU();
        return builder.getComputer();
    }
}

2.5 客户端代码

最后，客户端代码通过Director类来构建不同配置的电脑：

public class Client {
    public static void main(String[] args) {
        // 高配电脑
        ComputerBuilder highEndBuilder = new HighEndComputerBuilder();
        Director highEndDirector = new Director(highEndBuilder);
        Computer highEndComputer = highEndDirector.construct();
        System.out.println("High-End Computer: " + highEndComputer);

        // 低配电脑
        ComputerBuilder lowEndBuilder = new LowEndComputerBuilder();
        Director lowEndDirector = new Director(lowEndBuilder);
        Computer lowEndComputer = lowEndDirector.construct();
        System.out.println("Low-End Computer: " + lowEndComputer);
    }
}

2.6 运行结果

High-End Computer: Computer [CPU=Intel i9, RAM=32GB, HDD=1TB SSD, GPU=NVIDIA RTX 3090]
Low-End Computer: Computer [CPU=Intel i3, RAM=8GB, HDD=500GB HDD, GPU=Integrated Graphics]