创建型-综合题-Builder

题目

Java设计模式练习题：建造者模式 - 电脑组装工厂

一、案例背景

在现实中，电脑由多个部件组成，如CPU、内存、硬盘、主机、显示器等。用户只需告知需要哪种类型的电脑（如笔记本、台式机、服务器），电脑组装工厂将按照预设配置自动完成电脑部件的组装，返回一个完整可用的电脑对象。

我们希望使用建造者模式来设计这个电脑组装系统：

  • 客户端只需指定电脑类型（例如：Laptop、Desktop、Server）；
  • 构造过程由工厂统一调度；
  • 不同类型的电脑由不同的构建器（Builder）实现组装逻辑；
  • 电脑最终由 Director 统一创建并返回给客户端。

二、任务说明

1. 请使用建造者设计模式完成以下功能：

· 定义产品类 Computer，包含部件：CPU、内存、硬盘、主机、显示器，提供属性设置与信息展示方法。

· 定义抽象建造者 ComputerBuilder，声明构建各个部件的方法及获取完整电脑的方法。

· 实现具体建造者：LaptopBuilder、DesktopBuilder、ServerBuilder，完成相应部件的构建逻辑。

· 定义指挥者 Director，统一调度构建顺序。

· 客户端通过 Director 使用不同 Builder 获取不同类型的电脑。

三、结构图（文字表示）

[Computer] ← 产品类

[ComputerBuilder] ← 抽象建造者
   ↑        ↑         ↑
[LaptopBuilder] [DesktopBuilder] [ServerBuilder] ← 具体建造者

[Director] ← 指挥者类

[Client] ← 客户端

四、示例运行结果

Laptop configuration:
CPU: Intel i5
Memory: 16GB
Hard Disk: 512GB SSD
Main Unit: Compact case
Display: 13.3 inch

Server configuration:
CPU: Intel Xeon
Memory: 64GB ECC
Hard Disk: 2TB SAS
Main Unit: Rack case
Display: None

五、提示建议

• 产品类可定义多个 setter 方法用于构建器注入部件。

• 每个具体 Builder 实现各自的组装细节。

• Director 内部按统一顺序调用 builder 的各个步骤。

代码实现

PlantUML

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
@startuml
!theme plain

' 产品类
class Computer {
    - cpu: String
    - memory: String
    - hardDisk: String
    - mainUnit: String
    - display: String
    + setCpu(cpu: String): void
    + setMemory(memory: String): void
    + setHardDisk(hardDisk: String): void
    + setMainUnit(mainUnit: String): void
    + setDisplay(display: String): void
    + showConfiguration(): void
}

' 抽象建造者
abstract class ComputerBuilder {
    # computer: Computer
    + {abstract} buildCpu(): void
    + {abstract} buildMemory(): void
    + {abstract} buildHardDisk(): void
    + {abstract} buildMainUnit(): void
    + {abstract} buildDisplay(): void
    + getComputer(): Computer
}

' 具体建造者
class LaptopBuilder {
    + buildCpu(): void
    + buildMemory(): void
    + buildHardDisk(): void
    + buildMainUnit(): void
    + buildDisplay(): void
}

class DesktopBuilder {
    + buildCpu(): void
    + buildMemory(): void
    + buildHardDisk(): void
    + buildMainUnit(): void
    + buildDisplay(): void
}

class ServerBuilder {
    + buildCpu(): void
    + buildMemory(): void
    + buildHardDisk(): void
    + buildMainUnit(): void
    + buildDisplay(): void
}

' 指挥者
class Director {
    + construct(builder: ComputerBuilder): Computer
}

' 客户端
class Client_3 {
    + {static} main(args: String[]): void
}

' 关系定义
ComputerBuilder <|-- LaptopBuilder
ComputerBuilder <|-- DesktopBuilder
ComputerBuilder <|-- ServerBuilder

ComputerBuilder ..> Computer : builds >
Director o-- ComputerBuilder : uses >
Client_3 ..> Director
Client_3 ..> ComputerBuilder
Client_3 ..> Computer

@enduml

源码

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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
  
// Java设计模式练习题：建造者模式 - 电脑组装工厂  
// 建造者模式  
  
// 产品类: Computer  
class Computer {  
    private String cpu;  
    private String memory;  
    private String hardDisk;  
    private String mainUnit;  
    private String display;  
  
    public void setCpu(String cpu) {  
        this.cpu = cpu;  
    }  
  
    public void setMemory(String memory) {  
        this.memory = memory;  
    }  
  
    public void setHardDisk(String hardDisk) {  
        this.hardDisk = hardDisk;  
    }  
  
    public void setMainUnit(String mainUnit) {  
        this.mainUnit = mainUnit;  
    }  
  
    public void setDisplay(String display) {  
        this.display = display;  
    }  
  
    public void showConfiguration() {  
        System.out.println("CPU: " + cpu);  
        System.out.println("Memory: " + memory);  
        System.out.println("Hard Disk: " + hardDisk);  
        System.out.println("Main Unit: " + mainUnit);  
        System.out.println("Display: " + display);  
    }  
}  
  
// 抽象建造者: ComputerBuilder  
abstract class ComputerBuilder {  
    protected Computer computer = new Computer();  
  
    public abstract void buildCpu();  
    public abstract void buildMemory();  
    public abstract void buildHardDisk();  
    public abstract void buildMainUnit();  
    public abstract void buildDisplay();  
  
    public Computer getComputer() {  
        return computer;  
    }  
}  
  
// 具体建造者: LaptopBuilder  
class LaptopBuilder extends ComputerBuilder {  
    @Override  
    public void buildCpu() {  
        computer.setCpu("Intel i5");  
    }  
  
    @Override  
    public void buildMemory() {  
        computer.setMemory("16GB");  
    }  
  
    @Override  
    public void buildHardDisk() {  
        computer.setHardDisk("512GB SSD");  
    }  
  
    @Override  
    public void buildMainUnit() {  
        computer.setMainUnit("Compact case");  
    }  
  
    @Override  
    public void buildDisplay() {  
        computer.setDisplay("13.3 inch");  
    }  
}  
  
// 具体建造者: DesktopBuilder  
class DesktopBuilder extends ComputerBuilder {  
    @Override  
    public void buildCpu() {  
        computer.setCpu("Intel i7");  
    }  
  
    @Override  
    public void buildMemory() {  
        computer.setMemory("32GB");  
    }  
  
    @Override  
    public void buildHardDisk() {  
        computer.setHardDisk("1TB NVMe SSD");  
    }  
  
    @Override  
    public void buildMainUnit() {  
        computer.setMainUnit("Mid-tower case");  
    }  
  
    @Override  
    public void buildDisplay() {  
        computer.setDisplay("27 inch");  
    }  
}  
  
// 具体建造者: ServerBuilder  
class ServerBuilder extends ComputerBuilder {  
    @Override  
    public void buildCpu() {  
        computer.setCpu("Intel Xeon");  
    }  
  
    @Override  
    public void buildMemory() {  
        computer.setMemory("64GB ECC");  
    }  
  
    @Override  
    public void buildHardDisk() {  
        computer.setHardDisk("2TB SAS");  
    }  
  
    @Override  
    public void buildMainUnit() {  
        computer.setMainUnit("Rack case");  
    }  
  
    @Override  
    public void buildDisplay() {  
        computer.setDisplay("None"); // 服务器通常不直接连接显示器  
    }  
}  
  
// 指挥者: Director  
class Director {  
    public Computer construct(ComputerBuilder builder) {  
        builder.buildCpu();  
        builder.buildMemory();  
        builder.buildHardDisk();  
        builder.buildMainUnit();  
        builder.buildDisplay();  
        return builder.getComputer();  
    }  
}  
  
// 客户端: Client  
public class Client_3 {  
    public static void main(String[] args) {  
        Director director = new Director();  
  
        // 组装笔记本电脑  
        System.out.println("Laptop configuration:");  
        ComputerBuilder laptopBuilder = new LaptopBuilder();  
        Computer laptop = director.construct(laptopBuilder);  
        laptop.showConfiguration();  
        System.out.println();  
  
        // 组装台式电脑  
        System.out.println("Desktop configuration:");  
        ComputerBuilder desktopBuilder = new DesktopBuilder();  
        Computer desktop = director.construct(desktopBuilder);  
        desktop.showConfiguration();  
        System.out.println();  
  
        // 组装服务器  
        System.out.println("Server configuration:");  
        ComputerBuilder serverBuilder = new ServerBuilder();  
        Computer server = director.construct(serverBuilder);  
        server.showConfiguration();  
        System.out.println();  
    }  
}