设计模式3-生成器模式

1. 概念

        生成器模式（Builder Pattern）是一种创建型设计模式，旨在通过一步一步构建复杂对象来创建对象。这种模式允许你使用相同的构建过程来创建不同的表示形式。

        

问题背景

在软件开发中，有时候我们需要构建一个复杂的对象，这个对象可能包含多个部分，每个部分都有自己的构建步骤和规则。如果直接在客户端代码中创建这个复杂对象，会导致代码复杂，难以维护，也不利于对象的重用。

解决方案

生成器模式通过将构建复杂对象的过程拆分成多个步骤，每个步骤由一个生成器（Builder）负责完成，从而实现对象的创建。生成器模式的核心思想是将对象的构建和表示分离，使得相同的构建过程可以创建不同的表示形式。

关键角色

1. 产品（Product）：需要创建的复杂对象，它由多个部件组成。

2. 生成器接口（Builder Interface）：定义了构建复杂对象各个部件的方法。

3. 具体生成器（Concrete Builder）：实现了生成器接口，负责构建复杂对象的各个部件，并提供一个方法返回构建好的对象。

4. 指挥者（Director）：负责按照一定的构建步骤来指导生成器构建产品。

实现步骤

1. 定义产品类：描述需要构建的复杂对象，包含多个部件。

2. 定义生成器接口：声明构建产品各个部件的方法。

3. 实现具体生成器：实现生成器接口，逐步构建产品的各个部件，并提供一个方法返回构建好的产品。

4. 定义指挥者：按照一定的构建步骤调用生成器的方法来构建产品

2.代码实例

        1. 定义产品类 Computer

public class Computer {
    private String cpu;
    private String memory;
    private String disk;

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", memory='" + memory + '\'' +
                ", disk='" + disk + '\'' +
                '}';
    }
}

2. 定义生成器接口 ComputerBuilder

public interface ComputerBuilder {
    void buildCpu();
    void buildMemory();
    void buildDisk();
    Computer getComputer();
}

3. 实现具体生成器 ConcreteComputerBuilder

public class ConcreteComputerBuilder implements ComputerBuilder {
    private Computer computer;

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

    @Override
    public void buildCpu() {
        computer.setCpu("Intel Core i7");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("16GB");
    }

    @Override
    public void buildDisk() {
        computer.setDisk("512GB SSD");
    }

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

4. 定义指挥者 Director

public class Director {
    private ComputerBuilder computerBuilder;

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

    public void constructComputer() {
        computerBuilder.buildCpu();
        computerBuilder.buildMemory();
        computerBuilder.buildDisk();
    }
}

5. 客户端代码示例

public class Client {
    public static void main(String[] args) {
        // 创建具体生成器
        ComputerBuilder builder = new ConcreteComputerBuilder();

        // 创建指挥者
        Director director = new Director(builder);

        // 构建电脑
        director.constructComputer();

        // 获取构建好的电脑对象
        Computer computer = builder.getComputer();

        // 打印电脑配置
        System.out.println("Computer Configuration: ");
        System.out.println(computer);
    }
}

这个例子中，我们使用了生成器模式来构建一个电脑对象，将构建过程与产品分离，使得构建过程更加灵活和可控。指挥者负责按照一定的构建步骤来指导生成器构建产品，客户端代码只需要与指挥者和具体生成器交互，而不需要了解产品的具体构建细节。