每日日报9——软件设计⑤|建造者模式（计算机组装）

一、建造者模式

https://baike.baidu.com/item/%E5%BB%BA%E9%80%A0%E8%80%85%E6%A8%A1%E5%BC%8F/3229729?fr=aladdin

二、版本

（一）C++版本：

① 类图：

② 效果：

③ 代码：

main.cpp

  1 #include <iostream>
  2 #include <string>
  3 #include <list>
  4 using namespace std;
  5 
  6 //产品类，一般有多个部件构成
  7 class Computer
  8 {
  9 public:
 10     //函数功能：给电脑选择一个配件
 11     //参数：    string componentName[IN]                   -- 配件名称
 12     //返回值：  无
 13     void Select(string componentName)
 14     {
 15         this->m_ComponentsList.push_back(componentName);
 16     }
 17 
 18     //函数功能：显示电脑配件清单
 19     //参数：    无
 20     //返回值：  无
 21     void ShowComponets()
 22     {
 23         cout << "该款电脑配置清单如下：" << endl;
 24         list<string>::iterator iter;
 25         for (iter = this->m_ComponentsList.begin(); iter != this->m_ComponentsList.end(); ++iter)
 26         {
 27             cout << *iter << endl;
 28         }
 29     }
 30 private:
 31     list<string> m_ComponentsList;                 //电脑配件列表
 32 };
 33 
 34 //建造者类
 35 class Abstract_Builder
 36 {
 37 public:
 38     virtual void BuildCpu() = 0;                  //抽象CPU构建函数
 39     virtual void BuildMemory() = 0;               //抽象内存构建函数
 40     virtual void BuildHD() = 0;                   //抽象硬盘构建函数
 41     virtual void BuildHost() = 0;               //抽象主机构建函数
 42     virtual void BuildVideoCard() = 0;            //抽线显卡构建函数
 43 
 44     virtual Computer GetComputer() = 0;            //抽象获取产品函数
 45 };
 46 
 47 //具体建造者类1，用于构建笔记本电脑
 48 class NotebookComputerBuilder :public Abstract_Builder
 49 {
 50 public:
 51     void BuildCpu()                             //具体CPU构建函数
 52     {
 53         this->m_Computer.Select("笔记本电脑CPU");
 54     }
 55 
 56     void BuildMemory()                           //具体内存构建函数
 57     {
 58         this->m_Computer.Select("笔记本电脑内存");
 59     }
 60 
 61     void BuildHD()                           //具体硬盘构建函数
 62     {
 63         this->m_Computer.Select("笔记本电脑硬盘");
 64     }
 65 
 66     void BuildHost()                           //具体主机构建函数
 67     {
 68         this->m_Computer.Select("笔记本电脑主机");
 69     }
 70 
 71     void BuildVideoCard()                      //具体显卡构建函数
 72     {
 73         this->m_Computer.Select("笔记本电脑显卡");
 74     }
 75 
 76     Computer GetComputer()                      //具体获取产品函数
 77     {
 78         return this->m_Computer;
 79     }
 80 private:
 81     Computer m_Computer;                        //产品对象
 82 };
 83 
 84 
 85 //具体建造者类1，用于构建台式机电脑
 86 class DesktopComputerBuilder :public Abstract_Builder
 87 {
 88 public:
 89     void BuildCpu()                             //具体CPU构建函数
 90     {
 91         this->m_Computer.Select("台式机电脑CPU");
 92     }
 93 
 94     void BuildMemory()                           //具体内存构建函数
 95     {
 96         this->m_Computer.Select("台式机电脑内存");
 97     }
 98 
 99     void BuildHD()                           //具体硬盘构建函数
100     {
101         this->m_Computer.Select("台式机电脑硬盘");
102     }
103 
104     void BuildHost()                           //具体主机构建函数
105     {
106         this->m_Computer.Select("台式机电脑主机");
107     }
108 
109     void BuildVideoCard()                      //具体显卡构建函数
110     {
111         this->m_Computer.Select("台式机电脑显卡");
112     }
113 
114     Computer GetComputer()                      //具体获取产品函数
115     {
116         return this->m_Computer;
117     }
118 private:
119     Computer m_Computer;                        //产品对象
120 };
121 
122 //指挥者类，用来指挥构建的过程
123 class Assember
124 {
125 public:
126     //函数功能：组装电脑
127     //参数：    Abstract_Builder builder[IN]                  -- 构建者
128     //返回值：  无
129     void Assembly(Abstract_Builder* builder)
130     {
131         builder->BuildCpu();
132         builder->BuildMemory();
133         builder->BuildHD();
134         builder->BuildHost();
135         builder->BuildVideoCard();
136     }
137 };
138 
139 int main()
140 {
141     Assember pcAssember;
142 
143     //组装笔记本电脑
144     cout << "--开始组装笔记本电脑--" << endl;
145 
146     //组装游戏电脑
147     Abstract_Builder* pBuilder1 = new NotebookComputerBuilder();
148     if (NULL != pBuilder1)
149     {
150         pcAssember.Assembly(pBuilder1);
151 
152         Computer pc = pBuilder1->GetComputer();
153         pc.ShowComponets();
154 
155         delete pBuilder1;
156         pBuilder1 = NULL;
157     }
158     cout << "组装成功！" << endl;
159 
160     //组装台式机电脑
161     cout << "--开始组装台式机电脑--" << endl;
162 
163     Abstract_Builder* pBuilder2 = new DesktopComputerBuilder();
164     if (NULL != pBuilder2)
165     {
166         pcAssember.Assembly(pBuilder2);
167 
168         Computer pc = pBuilder2->GetComputer();
169         pc.ShowComponets();
170 
171         delete pBuilder2;
172         pBuilder2 = NULL;
173     }
174     cout << "组装成功！" << endl;
175 
176     getchar();
177     return 0;
178 }

参考链接：https://blog.csdn.net/u014337397/article/details/80385647

（二）Java版本

①类图：

②效果图：

③目录结构：

④代码：

Builder.java

 1 package assembly;
 2 
 3 public abstract class Builder {
 4     // 组装CPU
 5     public abstract Builder buildCPU(String cpu);
 6 
 7     // 组装显示器
 8     public abstract Builder buildDisplay(String display);
 9 
10     // 组装内存
11     public abstract Builder buildMemory(String memory);
12 
13     // 组装硬盘
14     public abstract Builder buildHD(String HD);
15 
16     //组装主机
17     public abstract Builder buildHost(String host);
18     
19     // 完成组装
20     public abstract Computer create();
21 }

Computer.java

 1 package assembly;
 2 
 3 public abstract class Computer {
 4     private String mCPU;
 5     private String mDisplay;
 6     private String mMemory;
 7     private String mHD;
 8     private String mHost;
 9 
10     // 配置CPU
11     public void setmCPU(String mCPU) {
12         this.mCPU = mCPU;
13     }
14 
15     // 配置显示器
16     public void setmDisplay(String mDisplay) {
17         this.mDisplay = mDisplay;
18     }
19 
20     // 配置内存
21     public void setmMemory(String mMemory) {
22         this.mMemory = mMemory;
23     }
24 
25     // 配置硬盘
26     public void setmHD(String mHD) {
27         this.mHD = mHD;
28     }
29 
30     // 配置主机
31     public void setmHost(String mHost) {
32         this.mHost = mHost;
33     }
34 
35     public String listHardware() {
36         return mCPU + '
' + mDisplay + '
' + mMemory + '
' + mHD + '
' + mHost;
37     }
38 }

Main.java

 1 package assembly;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5         //初始化建造器
 6         Builder builer = new MyComputerBuilder();
 7         //需要的配置为Intel CPU，AOC显示器，8G内存
 8         Computer computer = builer.buildCPU("组装CPU成功").buildDisplay("组装显示器成功").buildMemory("组装内存成功").buildHD("组装硬盘成功").buildHost("组装主机成功").create();
 9         System.out.println(computer.listHardware()+'
'+"组装完成！");
10     }
11 }

MyComputer.java

1 package assembly;
2 
3 public class MyComputer extends Computer {
4     protected MyComputer() {
5     };
6 }

MyComputerBuilder.java

 1 package assembly;
 2 
 3 public class MyComputerBuilder extends Builder {
 4     private Computer mComputer = new MyComputer();
 5 
 6     @Override
 7     public Builder buildCPU(String cpu) {
 8         mComputer.setmCPU(cpu);
 9         return this;
10     }
11 
12     @Override
13     public Builder buildDisplay(String display) {
14         mComputer.setmDisplay(display);
15         return this;
16     }
17 
18     @Override
19     public Builder buildMemory(String memory) {
20         mComputer.setmMemory(memory);
21         return this;
22     }
23 
24     @Override
25     public Builder buildHD(String HD) {
26         mComputer.setmHD(HD);
27         return this;
28     }
29 
30     @Override
31     public Builder buildHost(String host) {
32         mComputer.setmHost(host);
33         return this;
34     }
35 
36     @Override
37     public Computer create() {
38         return mComputer;
39     }
40 
41 }