软件设计实验5：建造者模式

实验5：建造者模式

本次实验属于模仿型实验，通过本次实验学生将掌握以下内容：

1、理解建造者模式的动机，掌握该模式的结构；

2、能够利用建造者模式解决实际问题。

 

[实验任务一]：计算机组装

使用建造者模式，完成下述任务：计算机组装工厂可以将CPU、内存、硬盘、主机等硬件设备组装在一起构成计算机，计算机的类型可以是笔记本，也可以是台式机。

实验要求：

1.画出对应的类图；

 

2. 提交源代码；

1. 1.Builder  
3. public abstract class Builder {  
5. Computer computer = new Computer();  
7. abstract public void buildZhuJi();  
9. abstract public void buildYinPan();  
11. abstract public void buildCpu();  
13. abstract public void buildNeiCun();  
15. public Compture getCompture(){  
17. return compture;  
19. }  
21. }  
22. public class Compture {  
24. private String cpu;  
26. private String neiCun;  
28. private String yinPan;  
30. private String zhuJi;  
31. public String getZhuJi() {  
33. return zhuJi;  
35. }  
36. public void setZhuJi(String zhuJi) {  
38. this.zhuJi = zhuJi;  
40. }  
41. public String getYinPan() {  
43. return yinPan;  
45. }  
49. public void setYinPan(String yinPan) {  
51. this.yinPan = yinPan;  
53. }  
54. public String getNeiCun() {  
56. return neiCun;  
58. }  
59. public void setNeiCun(String neiCun) {  
61. this.neiCun = neiCun;  
63. }  
64. public String getCpu() {  
66. return cpu;  
68. }
69. public void setCpu(String cpu) {  
71. this.cpu = cpu;  
73. }  
75. }  
78. public class Factory {  
80. private Builder comptureKind;  
84. public void setCompture(Builder kind) {  
86. this.comptureKind = kind;  
88. }  
90. public Compture construct(){  
92. comptureKind.buildCpu();  
94. comptureKind.buildYinPan();  
96. comptureKind.buildZhuJi();  
98. comptureKind.buildNeiCun();  
100. return comptureKind.getCompture();  
102. }  
104. }  
105. public class LapBuilder extends Builder{  
107. @Override  
109. public void buildZhuJi() {  
111. compture.setZhuJi("LZJ");  
113. }  
117. @Override  
119. public void buildYinPan() {  
121. compture.setYinPan("LYP");  
123. }  
124. @Override  
126. public void buildCpu() {  
128. compture.setCpu("LC");  
130. }  
134. @Override  
136. public void buildNeiCun() {  
138. compture.setNeiCun("LNC");  
140. }  
142. }  
146. ④ Store  
148. public class Store {  
150. public static void main(String[] args) {  
152. Builder lap;  
154. Factory factory=new Factory();  
156. for (int i = 0; i < 2; i++) {  
158. if(i==1)  
160. lap = new LapBuilder();  
162. else  
164. lap=new TaiShiBuilder();  
166. factory.setCompture(lap);  
168. factory.construct();  
170. System.out.println(lap.getCompture().getCpu());  
172. System.out.println(lap.getCompture().getNeiCun());  
174. System.out.println(lap.getCompture().getYinPan());  
176. System.out.println(lap.getCompture().getZhuJi());  
178. }  
182. }  
184. }  
186. public class TaiShiBuilder extends Builder{  
187. @Override  
189. public void buildZhuJi() {  
191. compture.setZhuJi("TZJ");  
193. }  
194. @Override  
196. public void buildYinPan() {  
198. compture.setYinPan("TYP");  
200. }  
201. @Override  
203. public void buildCpu() {  
205. compture.setCpu("TC");  
207. }  
209. @Override  
211. public void buildNeiCun() {  
213. compture.setNeiCun("TNC");  
215. }  
217. }  
218. #include "stdafx.h"  
220. using namespace std;  
222. class Compture {  
224. private:  
226. string cpu;  
228. string neiCun;  
230. string yinPan;  
232. string zhuJi;  
234. public:  
236. string getZhuJi() {  
238. return zhuJi;  
240. }  
242. void setZhuJi(string z) {  
244. zhuJi = z;  
246. }  
247. string getYinPan() {  
249. return yinPan;  
251. }  
252. void setYinPan(string y) {  
254. yinPan = y;  
256. }  
257. string getNeiCun() {  
259. return neiCun;  
261. }  
262. void setNeiCun(string n) {  
264. neiCun = n;  
266. }  
267. string getCpu() {  
269. return cpu;  
271. }  
272. void setCpu(string c) {  
274. cpu = c;  
276. }  
278. };  
279. class Builder {  
280. public:  
282. Compture* compture = new Compture();  
284. virtual  void buildZhuJi() = 0;  
286. virtual  void buildYinPan() = 0;  
288. virtual  void buildCpu() = 0;  
290. virtual  void buildNeiCun() = 0;  
292. public:  
294. Compture* getCompture(){  
296. return compture;  
298. }  
300. };  
302. class Factory {  
304. private:  
306. Builder* comptureKind;  
307. public:  
309. void setCompture(Builder* kind) {  
311. comptureKind = kind;  
313. }  
315. Compture* construct(){  
317. comptureKind->buildCpu();  
319. comptureKind->buildYinPan();  
321. comptureKind->buildZhuJi();  
323. comptureKind->buildNeiCun();  
325. return comptureKind->getCompture();  
327. }  
329. };  
331. class LapBuilder :public Builder{  
332. public:  
334. void buildZhuJi() {  
336. compture->setZhuJi("LZJ");  
338. }  
344. void buildYinPan() {  
346. compture->setYinPan("LYP");  
348. }  
349. void buildCpu() {  
351. compture->setCpu("LC");  
353. }  
354. void buildNeiCun() {  
356. compture->setNeiCun("LNC");  
358. }  
360. };  
361. class TaiShiBuilder :public Builder{  
362. public:  
364. void buildZhuJi() {  
366. compture->setZhuJi("TZJ");  
368. }  
369. void buildYinPan() {  
371. compture->setYinPan("TYP");  
373. }  
374. void buildCpu() {  
376. compture->setCpu("TC");  
378. }  
380. void buildNeiCun() {  
382. compture->setNeiCun("TNC");  
384. }  
386. };  
390. int main()  
392. {  
394. Builder* lap;  
396. Factory* factory = new Factory();  
398. for (int i = 0; i < 2; i++) {  
400. if (i == 1)  
402. lap = new LapBuilder();  
404. else  
406. lap = new TaiShiBuilder();  
408. factory->setCompture(lap);  
410. factory->construct();  
412. cout << lap->getCompture()->getCpu()<<endl;  
414. cout << lap->getCompture()->getNeiCun()<<endl;  
416. cout << lap->getCompture()->getYinPan()<<endl;  
418. cout << lap->getCompture()->getZhuJi() << endl;  
420. }  
422. system("pause");  
424. return 0;  
426. }  

 

3.注意编程规范。