设计模式之——建造者模式

1

建造者模式在抽象类的构造上有点像模板方法，类方法是在父类中构造的而非子类继承重写，首先以最常用的类开始：

  1 package Jianzaozhe;
  2
  3 import java.util.ArrayList;
  4 import java.util.List;
  5
  6 public class Client {
  7     public static void main(String[] args) {
  8         BenzModel benzModel = new BenzModel();
  9         ArrayList<String>sequence = new ArrayList<>();
 10         sequence.add("engine boom");
 11         sequence.add("start");
 12         sequence.add("stop");
 13         benzModel.setSequence(sequence);
 14         benzModel.run();
 15     }
 16 }
 17
 18 abstract class CarModel {
 19     private List<String> sequence = new ArrayList<>();
 20
 21     protected abstract void start();
 22
 23     protected abstract void stop();
 24
 25     protected abstract void alarm();
 26
 27     protected abstract void engineBoom();
 28
 29     final public void run() {
 30         for (int i = 0; i < this.sequence.size(); i++) {
 31             String actionName = this.sequence.get(i);
 32             if (actionName.equalsIgnoreCase("start")) {
 33                 this.start(); // 开启汽车
 34             } else if (actionName.equalsIgnoreCase("stop")) {
 35                 this.stop(); // 停止汽车
 36             } else if (actionName.equalsIgnoreCase("alarm")) {
 37                 this.alarm(); // 喇叭开始叫了
 38             } else if (actionName.equalsIgnoreCase("engine boom")) { // 如果是engine
 39                                                                         // boom关键字
 40                 this.engineBoom(); // 引擎开始轰鸣
 41             }
 42         }
 43     }
 44
 45     public List<String> getSequence() {
 46         return sequence;
 47     }
 48
 49     public void setSequence(List<String> sequence) {
 50         this.sequence = sequence;
 51     }
 52
 53 }
 54
 55 class BenzModel extends CarModel {
 56
 57     @Override
 58     protected void start() {
 59         // TODO Auto-generated method stub
 60         System.out.println("奔驰开始了...");
 61     }
 62
 63     @Override
 64     protected void stop() {
 65         // TODO Auto-generated method stub
 66         System.out.println("奔驰停止了...");
 67     }
 68
 69     @Override
 70     protected void alarm() {
 71         // TODO Auto-generated method stub
 72         System.out.println("奔驰按喇叭...");
 73     }
 74
 75     @Override
 76     protected void engineBoom() {
 77         // TODO Auto-generated method stub
 78         System.out.println("奔驰引擎开启...");
 79     }
 80
 81 }
 82
 83 class BMWModel extends CarModel {
 84     @Override
 85     protected void start() {
 86         // TODO Auto-generated method stub
 87         System.out.println("宝马开始了...");
 88     }
 89
 90     @Override
 91     protected void stop() {
 92         // TODO Auto-generated method stub
 93         System.out.println("宝马停止了...");
 94     }
 95
 96     @Override
 97     protected void alarm() {
 98         // TODO Auto-generated method stub
 99         System.out.println("宝马按喇叭...");
100     }
101
102     @Override
103     protected void engineBoom() {
104         // TODO Auto-generated method stub
105         System.out.println("宝马引擎开启...");
106     }
107 }

测试结果：

奔驰引擎开启...
奔驰开始了...
奔驰停止了...

2

在Client类中可以选择我们要执行的动作的顺序，但是具体到每一个动作我们都要重新装配一遍，这样太麻烦了，我们可以为每个模型定义一个装配类，由它来定义子类东走执行的顺序：

 1 abstract class CarBuilder{
 2     public abstract void setSequence(List<String> sequence);
 3     public abstract CarModel getCarModel();
 4 }
 5
 6 class BenzBuilder extends CarBuilder{
 7
 8     private BenzModel benzModel = new BenzModel();
 9     @Override
10     public void setSequence(List<String> sequence) {
11         // TODO Auto-generated method stub
12         this.benzModel.setSequence(sequence);
13     }
14
15     @Override
16     public CarModel getCarModel() {
17         // TODO Auto-generated method stub
18         return this.benzModel;
19     }
20
21 }
22
23 class BMWBuilder extends CarBuilder{
24     private BMWModel bmwModel = new BMWModel();
25
26     @Override
27     public void setSequence(List<String> sequence) {
28         // TODO Auto-generated method stub
29         this.bmwModel.setSequence(sequence);
30     }
31
32     @Override
33     public CarModel getCarModel() {
34         // TODO Auto-generated method stub
35         return this.bmwModel;
36     }
37
38 }

修改Client

 1 public class Client{
 2     public static void main(String[] args) {
 3         List<String>sequence = new ArrayList<>();
 4         sequence.add("engine boom");
 5         sequence.add("start");
 6         sequence.add("stop");
 7
 8         BenzBuilder benzBuilder = new BenzBuilder();
 9         benzBuilder.setSequence(sequence);
10         BenzModel benzModel = (BenzModel)benzBuilder.getCarModel();
11         benzModel.run();
12
13         BMWBuilder bmwBuilder = new BMWBuilder();
14         bmwBuilder.setSequence(sequence);
15         BMWModel bmwModel = (BMWModel)bmwBuilder.getCarModel();
16         bmwModel.run();
17     }
18 }

测试结果：

奔驰引擎开启...
奔驰开始了...
奔驰停止了...
宝马引擎开启...
宝马开始了...
宝马停止了...

3

上面利用Builder对getModel和getSequence两个方法进行了封装，对于未知顺序的类我们还是无法改变，这时就要利用导演类Director了：

 1 class Director{
 2     private List<String>sequence = new ArrayList<>();
 3     private BenzBuilder benzBuilder = new BenzBuilder();
 4     private BMWBuilder bmwBuilder = new BMWBuilder();
 5
 6     public BenzModel getABenzModel(){
 7         this.sequence.clear();
 8         this.sequence.add("start");
 9         this.sequence.add("stop");
10         this.benzBuilder.setSequence(sequence);
11         return (BenzModel)this.benzBuilder.getCarModel();
12     }
13
14     public BenzModel getBBenzModel(){
15         this.sequence.clear();
16         this.sequence.add("engine boom");
17         this.sequence.add("alarm");
18         this.benzBuilder.setSequence(sequence);
19         return (BenzModel)this.benzBuilder.getCarModel();
20     }
21
22     public BMWModel getABmwModel(){
23         this.sequence.clear();
24         this.sequence.add("start");
25         this.sequence.add("stop");
26         this.bmwBuilder.setSequence(sequence);
27         return (BMWModel)this.bmwBuilder.getCarModel();
28     }
29
30     public BMWModel getBBmwModel(){
31         this.sequence.clear();
32         this.sequence.add("engine boom");
33         this.sequence.add("alarm");
34         this.benzBuilder.setSequence(sequence);
35         return (BMWModel)this.bmwBuilder.getCarModel();
36     }
37 }

修改Client

 1 public class Client{
 2     public static void main(String[] args) {
 3         Director director = new Director();
 4         for (int i = 0; i < 5; i++) {
 5             director.getABenzModel().run();
 6         }
 7         for (int i = 0; i < 5; i++) {
 8             director.getBBenzModel().run();
 9         }
10         for (int i = 0; i < 5; i++) {
11             director.getABmwModel().run();
12         }
13         for (int i = 0; i < 5; i++) {
14             director.getBBmwModel().run();
15         }
16     }
17 }

测试结果：

奔驰开始了...
奔驰停止了...
奔驰开始了...
奔驰停止了...
奔驰开始了...
奔驰停止了...
奔驰开始了...
奔驰停止了...
奔驰开始了...
奔驰停止了...
奔驰引擎开启...
奔驰按喇叭...
奔驰引擎开启...
奔驰按喇叭...
奔驰引擎开启...
奔驰按喇叭...
奔驰引擎开启...
奔驰按喇叭...
奔驰引擎开启...
奔驰按喇叭...
宝马开始了...
宝马停止了...
宝马开始了...
宝马停止了...
宝马开始了...
宝马停止了...
宝马开始了...
宝马停止了...
宝马开始了...
宝马停止了...
宝马引擎开启...
宝马按喇叭...
宝马引擎开启...
宝马按喇叭...
宝马引擎开启...
宝马按喇叭...
宝马引擎开启...
宝马按喇叭...
宝马引擎开启...
宝马按喇叭...

所有代码如下：

  1 package Jianzaozhe;
  2
  3 import java.util.ArrayList;
  4 import java.util.List;
  5
  6 /*public class Client {
  7     public static void main(String[] args) {
  8         BenzModel benzModel = new BenzModel();
  9         List<String>sequence = new ArrayList<>();
 10         sequence.add("engine boom");
 11         sequence.add("start");
 12         sequence.add("stop");
 13         benzModel.setSequence(sequence);
 14         benzModel.run();
 15     }
 16 }*/
 17
 18 /*public class Client{
 19     public static void main(String[] args) {
 20         List<String>sequence = new ArrayList<>();
 21         sequence.add("engine boom");
 22         sequence.add("start");
 23         sequence.add("stop");
 24
 25         BenzBuilder benzBuilder = new BenzBuilder();
 26         benzBuilder.setSequence(sequence);
 27         BenzModel benzModel = (BenzModel)benzBuilder.getCarModel();
 28         benzModel.run();
 29
 30         BMWBuilder bmwBuilder = new BMWBuilder();
 31         bmwBuilder.setSequence(sequence);
 32         BMWModel bmwModel = (BMWModel)bmwBuilder.getCarModel();
 33         bmwModel.run();
 34     }
 35 }*/
 36
 37 public class Client{
 38     public static void main(String[] args) {
 39         Director director = new Director();
 40         for (int i = 0; i < 5; i++) {
 41             director.getABenzModel().run();
 42         }
 43         for (int i = 0; i < 5; i++) {
 44             director.getBBenzModel().run();
 45         }
 46         for (int i = 0; i < 5; i++) {
 47             director.getABmwModel().run();
 48         }
 49         for (int i = 0; i < 5; i++) {
 50             director.getBBmwModel().run();
 51         }
 52     }
 53 }
 54
 55 abstract class CarModel {
 56     private List<String> sequence = new ArrayList<>();
 57
 58     protected abstract void start();
 59
 60     protected abstract void stop();
 61
 62     protected abstract void alarm();
 63
 64     protected abstract void engineBoom();
 65
 66     final public void run() {
 67         for (int i = 0; i < this.sequence.size(); i++) {
 68             String actionName = this.sequence.get(i);
 69             if (actionName.equalsIgnoreCase("start")) {
 70                 this.start(); // 开启汽车
 71             } else if (actionName.equalsIgnoreCase("stop")) {
 72                 this.stop(); // 停止汽车
 73             } else if (actionName.equalsIgnoreCase("alarm")) {
 74                 this.alarm(); // 喇叭开始叫了
 75             } else if (actionName.equalsIgnoreCase("engine boom")) { // 如果是engine
 76                                                                         // boom关键字
 77                 this.engineBoom(); // 引擎开始轰鸣
 78             }
 79         }
 80     }
 81
 82     public List<String> getSequence() {
 83         return sequence;
 84     }
 85
 86     public void setSequence(List<String> sequence) {
 87         this.sequence = sequence;
 88     }
 89
 90 }
 91
 92 class BenzModel extends CarModel {
 93
 94     @Override
 95     protected void start() {
 96         // TODO Auto-generated method stub
 97         System.out.println("奔驰开始了...");
 98     }
 99
100     @Override
101     protected void stop() {
102         // TODO Auto-generated method stub
103         System.out.println("奔驰停止了...");
104     }
105
106     @Override
107     protected void alarm() {
108         // TODO Auto-generated method stub
109         System.out.println("奔驰按喇叭...");
110     }
111
112     @Override
113     protected void engineBoom() {
114         // TODO Auto-generated method stub
115         System.out.println("奔驰引擎开启...");
116     }
117
118 }
119
120 class BMWModel extends CarModel {
121     @Override
122     protected void start() {
123         // TODO Auto-generated method stub
124         System.out.println("宝马开始了...");
125     }
126
127     @Override
128     protected void stop() {
129         // TODO Auto-generated method stub
130         System.out.println("宝马停止了...");
131     }
132
133     @Override
134     protected void alarm() {
135         // TODO Auto-generated method stub
136         System.out.println("宝马按喇叭...");
137     }
138
139     @Override
140     protected void engineBoom() {
141         // TODO Auto-generated method stub
142         System.out.println("宝马引擎开启...");
143     }
144 }
145
146 abstract class CarBuilder{
147     public abstract void setSequence(List<String> sequence);
148     public abstract CarModel getCarModel();
149 }
150
151 class BenzBuilder extends CarBuilder{
152
153     private BenzModel benzModel = new BenzModel();
154     @Override
155     public void setSequence(List<String> sequence) {
156         // TODO Auto-generated method stub
157         this.benzModel.setSequence(sequence);
158     }
159
160     @Override
161     public CarModel getCarModel() {
162         // TODO Auto-generated method stub
163         return this.benzModel;
164     }
165
166 }
167
168 class BMWBuilder extends CarBuilder{
169     private BMWModel bmwModel = new BMWModel();
170
171     @Override
172     public void setSequence(List<String> sequence) {
173         // TODO Auto-generated method stub
174         this.bmwModel.setSequence(sequence);
175     }
176
177     @Override
178     public CarModel getCarModel() {
179         // TODO Auto-generated method stub
180         return this.bmwModel;
181     }
182
183 }
184
185 class Director{
186     private List<String>sequence = new ArrayList<>();
187     private BenzBuilder benzBuilder = new BenzBuilder();
188     private BMWBuilder bmwBuilder = new BMWBuilder();
189
190     public BenzModel getABenzModel(){
191         this.sequence.clear();
192         this.sequence.add("start");
193         this.sequence.add("stop");
194         this.benzBuilder.setSequence(sequence);
195         return (BenzModel)this.benzBuilder.getCarModel();
196     }
197
198     public BenzModel getBBenzModel(){
199         this.sequence.clear();
200         this.sequence.add("engine boom");
201         this.sequence.add("alarm");
202         this.benzBuilder.setSequence(sequence);
203         return (BenzModel)this.benzBuilder.getCarModel();
204     }
205
206     public BMWModel getABmwModel(){
207         this.sequence.clear();
208         this.sequence.add("start");
209         this.sequence.add("stop");
210         this.bmwBuilder.setSequence(sequence);
211         return (BMWModel)this.bmwBuilder.getCarModel();
212     }
213
214     public BMWModel getBBmwModel(){
215         this.sequence.clear();
216         this.sequence.add("engine boom");
217         this.sequence.add("alarm");
218         this.benzBuilder.setSequence(sequence);
219         return (BMWModel)this.bmwBuilder.getCarModel();
220     }
221 }

时间： 2024-08-27 14:01:52

设计模式之——建造者模式的相关文章

C++设计模式之建造者模式(二)

3.省略指挥者Director的建造者模式 指挥者类Director在建造者模式中扮演非常重要的作用,简单的Director类用于指导具体建造者如何构建产品,它按一定次序调用Builder的buildPartX()方法,控制调用的先后次序,并向客户端返回一个完整的产品对象.Direcotr针对抽象的建造者进行编程,如果需要不同的建造者,只需把建造者传入指挥者类,无需修改之前的代码. 在有些情况下,为了简化系统结构,可以省略指挥者Director,指挥者不再指导产品的创建过程.而是在Builder

C++设计模式之建造者模式(三)

4.引入钩子方法的建造者模式 建造者模式除了逐步构建一个复杂产品对象外,还可以通过Director类来更加精细地控制产品的创建过程,例如增加一类称之为钩子方法(HookMethod)的特殊方法来控制是否对某个buildPartX()的调用,也就是判断产品中某个部件是否需要被建造.钩子方法的返回类型通常为boolean类型,方法名一般为isXXX(),钩子方法定义在抽象建造者类中.在抽象建造者类中提供钩子方法的默认实现,具体建造者类如果不需要建造某个部件,则该建造者类覆盖抽象建造者类的钩子方法.

螃蟹学PHP设计模式之建造者模式

2.建造者模式 螃蟹今天要学习建造者模式了,昨天的适配器记得还是很清楚的.对于建造者模式,螃蟹的理解是你有10部iphone手机要充电,假设充电器额定电压都是220v,但是外电压不稳定,可能是220v,也可能是240v,或是300v,这个时候怎么办,可行的方法是购置一个家用变压器,把充电器都连在变压器上,不需要直接连在外电网上,无论外电压如何变化,只需要操作变压器即可.这个比喻可能有些牵强,不过还是能够说明建造者模式的用途,就是原对象可能是可变的,包括接收的参数或是方法等,但是如果我们已经在程序

大话设计模式_建造者模式(Java代码)

建造者模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示 简单描述:1个产品类(可有可无,关键是建造流程),1个抽象建造步骤类,多个具体建造子类(不同的类建造不同的产品),1个指挥者(用于规定建造流程),客户端指定需要建造的具体类型,由指挥者建造好之后,建造者子类返回对应产品给客户 大话设计模式中的截图: 例子代码: Product类: 1 package com.longsheng.builder; 2 3 public class Product { 4 5 pr

设计模式3——建造者模式

1解释 1.1定义 将一个复杂对象的构建与他的表示分离,使得同样的构建可以创建不同的表示. 1.2分析 首先我们看看一般的实例化对象的方法,如下面代码: Roboter roboter = new Roboter(); roboter.setmArm("arm"); roboter.setmBody("body"); roboter.setmHead("head"); roboter.setmFoot("foot"); 对于R

【设计模式】——建造者模式

建造者模式(Builder),将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 建造者模式结构图: Builder是为创建一个Product对象的各个部件指定的抽象接口:ConcreteBuilder是具体建造者,实现Builder接口,构建和装配各个部件:Product就是产品角色:Director是构建使用Builder接口的对象. 建造者模式主要用于创建一些复杂的对象,这些对象内部构建间的构造顺序通常是稳定的,但对象内部的构建通常面临着复杂的变化.它的好处就是使得

05.设计模式_建造者模式

转载自  http://www.cnblogs.com/zhili/p/BuilderPattern.html 一.引言 在软件系统中,有时需要创建一个复杂对象,并且这个复杂对象由其各部分子对象通过一定的步骤组合而成.例如一个采购系统中,如果需要采购员去采购一批电脑时,在这个实际需求中,电脑就是一个复杂的对象,它是由CPU.主板.硬盘.显卡.机箱等组装而成的,如果此时让采购员一台一台电脑去组装的话真是要累死采购员了,这里就可以采用建造者模式来解决这个问题,我们可以把电脑的各个组件的组装过程封装到

&lt;九&gt;读&lt;&lt;大话设计模式&gt;&gt;之建造者模式

学习了这么多模式,其实回想一下其实也没什么,就是用不同的方式设计代码,保证代码的可扩展性.复用等,稍微对代码进行一下修改就是另外一种模式.在我们工作中其实已经用了很多模式了,只不过不知道或者没留意他叫什么而已,无所谓,只要会用一切都是浮云. 关于<<大话设计模式>>对建造者模式的讲解是以画一个人来作为例子讲解的.人分为高人.矮人.胖人.瘦人等,但都是人,但当你去画一个人的时候,画的过程都是稳定的,都需要画头.身子.手.脚,不同的是建造的细节是不一样的.所以如果你需要将一个复杂的构件

C#设计模式之四建造者模式（Builder Pattern）【创建型】

原文:C#设计模式之四建造者模式(Builder Pattern)[创建型] 一.引言 今天我们要讲讲Builder模式,也就是建造者模式,当然也有叫生成器模式的,英文名称是Builder Pattern.在现实生活中,我们经常会遇到一些构成比较复杂的物品,比如:电脑,它就是一个复杂的物品,它主要是由CPU.主板.硬盘.显卡.机箱等组装而成的.手机当然也是复杂物品,由主板,各种芯片,RAM 和ROM  摄像头之类的东西组成.但是无论是电脑还是手机,他们的组装过程是固定的,就拿手机来说,组装流水线

C#设计模式(5)——建造者模式（Builder Pattern）

一.引言 在软件系统中,有时需要创建一个复杂对象,并且这个复杂对象由其各部分子对象通过一定的步骤组合而成.例如一个采购系统中,如果需要采购员去采购一批电脑时,在这个实际需求中,电脑就是一个复杂的对象,它是由CPU.主板.硬盘.显卡.机箱等组装而成的,如果此时让采购员一台一台电脑去组装的话真是要累死采购员了,这里就可以采用建造者模式来解决这个问题,我们可以把电脑的各个组件的组装过程封装到一个建造者类对象里,建造者只要负责返还给客户端全部组件都建造完毕的产品对象就可以了.然而现实生活中也是如此的,如