设计模式之建造者模式

定义

1
2
建造者模式（Builder）：将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示
建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时适用的模式

优点

1
2
3
可以创建复杂对象，同时保持构建代码的清晰性。
允许对象有不同的表示（如这里的游戏PC和办公PC）。
将对象的构建过程和表示分离。

代码解释

1
2
3
4
5
产品（Product）：Computer 类代表我们要构建的复杂对象。
抽象建造者（Builder）：ComputerBuilder 接口定义了构建产品各个部分的方法。
具体建造者（Concrete Builder）：ConcreteComputerBuilder 类实现了 ComputerBuilder 接口，负责实际构建 Computer 对象。
指挥者（Director）：Director 类控制构建过程，定义了不同类型的电脑构建顺序。
客户端（Client）：BuilderPatternDemo 类中的 main 方法演示了如何使用建造者模式。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
// 产品类
class Computer {
    private String cpu;
    private String ram;
    private String storage;
    private String gpu;

    public void setCpu(String cpu) { this.cpu = cpu; }
    public void setRam(String ram) { this.ram = ram; }
    public void setStorage(String storage) { this.storage = storage; }
    public void setGpu(String gpu) { this.gpu = gpu; }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", storage='" + storage + '\'' +
                ", gpu='" + gpu + '\'' +
                '}';
    }
}

// 抽象建造者
interface ComputerBuilder {
    void buildCpu(String cpu);
    void buildRam(String ram);
    void buildStorage(String storage);
    void buildGpu(String gpu);
    Computer getResult();
}

// 具体建造者
class ConcreteComputerBuilder implements ComputerBuilder {
    private Computer computer;

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

    @Override
    public void buildCpu(String cpu) { computer.setCpu(cpu); }

    @Override
    public void buildRam(String ram) { computer.setRam(ram); }

    @Override
    public void buildStorage(String storage) { computer.setStorage(storage); }

    @Override
    public void buildGpu(String gpu) { computer.setGpu(gpu); }

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

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

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

    public Computer constructGamingPC() {
        builder.buildCpu("Intel i9");
        builder.buildRam("32GB DDR4");
        builder.buildStorage("1TB NVMe SSD");
        builder.buildGpu("NVIDIA RTX 3080");
        return builder.getResult();
    }

    public Computer constructOfficePC() {
        builder.buildCpu("Intel i5");
        builder.buildRam("16GB DDR4");
        builder.buildStorage("512GB SSD");
        builder.buildGpu("Integrated Graphics");
        return builder.getResult();
    }
}

// 客户端代码
public class BuilderPatternDemo {
    public static void main(String[] args) {
        ComputerBuilder builder = new ConcreteComputerBuilder();
        Director director = new Director(builder);

        Computer gamingPC = director.constructGamingPC();
        System.out.println("Gaming PC: " + gamingPC);

        Computer officePC = director.constructOfficePC();
        System.out.println("Office PC: " + officePC);
    }
}