什么是建造者模式
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了什么是建造者模式相关的知识，希望对你有一定的参考价值。
建造者模式是设计模式的一种，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式
实用范围
1 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。[1]
2 当构造过程必须允许被构造的对象有不同表示时。
角色
在这样的设计模式中，有以下几个角色：
1 builder：为创建一个产品对象的各个部件指定抽象接口。
2 ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。
3 Director：构造一个使用Builder接口的对象。
4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
例子
Builder
public interface PersonBuilder
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();
//具体建造工具
ConcreteBuilder
public class ManBuilder implements PersonBuilder
Person person;
public ManBuilder()
person = new Person();
public void buildbody()
person.setBody("建造男人的身体");
public void buildFoot()
person.setFoot("建造男人的脚");
public void buildHead()
person.setHead("建造男人的头");
public Person buildPerson()
return person;
//建造者
Director
public class PersonDirector
public Person constructPerson(PersonBuilder pb)
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return pb.buildPerson();
Product
public class Person
private String head;
private String body;
private String foot;
public String getHead()
return head;
public void setHead(String head)
this.head = head;
public String getBody()
return body;
public void setBody(String body)
this.body = body;
public String getFoot()
return foot;
public void setFoot(String foot)
this.foot = foot;
public class Man extends Person
Test
public class Test
public static void main(String[] args)
PersonDirector pd = new PersonDirector();
Person person = pd.constructPerson(new ManBuilder());
System.out.println(person.getBody());
System.out.println(person.getFoot());
System.out.println(person.getHead());
result
建造男人的身体
建造男人的脚
建造男人的头
扩展
建造者模式在使用过程中可以演化出多种形式：
省略抽象建造者角色
如果系统中只需要一个具体的建造者的话，可以省略掉抽象建造者。这是代码可能如下：
class FoodManager
private:
BuilderA * builder;
public:
FoodManager() builder = new BuilderA();;
void Construct()
builder->BuildRiceNoodles();
builder->BuildDrink();
builder->BuildCoolDish();
;
省略指导者角色
在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略掉指导者角色，让Builder自己扮演指导者和建造者双重角色。这是代码可能如下：
//builder
class Builder
private:
Food * food;
public:
Builder()food = new Food();
void BuildRiceNoodles() //..;
void BuildCoolDish()//..;
void BuildDrink()//..;
Food * getFood()return food;
void Construct()
BuildRiceNoodles();
BuildCoolDish();
BuildDrink();
;
同时，客户端也需要进行相应的调整，如下：
//client
int _tmain(int argc, _TCHAR* argv[])
Builder * builder = new Builder();
builder->Construct();
Food *food = builder->getFood();
food->show();
return 0;
C#中的StringBuilder就是这样一个例子。 参考技术A 资源无限 无敌 啥都能拆 能飞
建造者模式
文章目录
一，建造者模式
1.什么是建造者模式
将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
2.建造者模式几大角色
抽象模型和具体实现模型
抽象模型就是你要建造的对象的抽象形式，比如，我现在要建造一辆车，但是车有很多种型号，那么，这些不同型号的车就是具体实现模型，车就是抽象模型
/**
* @Description: 抽象模型
* @Author: Kevin
* @CreateDate: 2019/6/17 0:44
* @UpdateUser: Kevin
* @UpdateDate: 2019/6/17 0:44
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public abstract class AbstractModel
//执行顺序
private ArrayList<String> sequence = new ArrayList<String>();
protected abstract void start();
protected abstract void alarm();
protected abstract void engineBoom();
protected abstract void stop();
public void run()
//根据执行顺序执行方法，组合成run方法
for(int i=0;i<this.sequence.size();i++)
String actionName = this.sequence.get(i);
if(actionName.equalsIgnoreCase("start"))
this.start();
//启动汽车
else if(actionName.equalsIgnoreCase("stop"))
this.stop();
//停止汽车
else if(actionName.equalsIgnoreCase("alarm"))
this.alarm();
//喇叭开始叫了
else if(actionName.equalsIgnoreCase("engineBoom"))
//如果是engine boom关键
this.engineBoom();
//引擎开始轰鸣
public void setSequence(ArrayList<String> sequence)
this.sequence = sequence;
具体实现模型：
/**
* @Description: 模型具体实现 --- A模型
* @Author: Kevin
* @CreateDate: 2019/6/17 0:47
* @UpdateUser: Kevin
* @UpdateDate: 2019/6/17 0:47
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class ModelA extends AbstractModel
@Override
protected void start()
System.out.println("---------> A 启动");
@Override
protected void alarm()
System.out.println("---------> A 鸣笛");
@Override
protected void engineBoom()
System.out.println("---------> A 引擎声");
@Override
protected void stop()
System.out.println("---------> A 停止");
/**
* @Description: 模型具体实现 --- B模型
* @Author: Kevin
* @CreateDate: 2019/6/17 0:47
* @UpdateUser: Kevin
* @UpdateDate: 2019/6/17 0:47
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class ModelB extends AbstractModel
@Override
protected void start()
System.out.println("---------> B 启动");
@Override
protected void alarm()
System.out.println("---------> B 鸣笛");
@Override
protected void engineBoom()
System.out.println("---------> B 引擎声响起");
@Override
protected void stop()
System.out.println("---------> B 停止");
抽象和具体建造者
抽象建造者：定义建造这辆车的抽象方法
/**
* @Description: 抽象模型建造者
* @Author: Kevin
* @CreateDate: 2019/6/17 0:58
* @UpdateUser: Kevin
* @UpdateDate: 2019/6/17 0:58
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public abstract class AbstractModelBuilder
public abstract AbstractModel getModel();
public abstract void setList(ArrayList<String> list);
具体建造者，具体建造某一型号的车的建造者
/**
* @Description: 模型A建造者
* @Author: Kevin
* @CreateDate: 2019/6/17 1:05
* @UpdateUser: Kevin
* @UpdateDate: 2019/6/17 1:05
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class ModelABuilder extends AbstractModelBuilder
private ModelA modelA = new ModelA();
@Override
public AbstractModel getModel()
return modelA;
@Override
public void setList(ArrayList<String> list)
modelA.setSequence(list);
/**
* @Description: 模型B建造者
* @Author: Kevin
* @CreateDate: 2019/6/17 1:05
* @UpdateUser: Kevin
* @UpdateDate: 2019/6/17 1:05
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class ModelBBuilder extends AbstractModelBuilder
private ModelB modelB = new ModelB();
@Override
public AbstractModel getModel()
return modelB;
@Override
public void setList(ArrayList<String> list)
modelB.setSequence(list);
导演
导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。在建造者模式比较庞大时，导演类可以有多个
/**
* @Description: 导演类
* @Author: Kevin
* @CreateDate: 2019/6/17 1:07
* @UpdateUser: Kevin
* @UpdateDate: 2019/6/17 1:07
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class Director
private ModelABuilder modelABuilder = new ModelABuilder();
private ModelBBuilder modelBBuilder = new ModelBBuilder();
private ArrayList<String> list = new ArrayList<>();
public ModelA getModelA1()
//clear的动作，以防止数据混乱
list.clear();
list.add("start");
list.add("alarm");
list.add("engineBoom");
list.add("stop");
modelABuilder.setList(list);
return (ModelA) modelABuilder.getModel();
public ModelA getModelA2()
list.clear();
list.add("start");
list.add("engineBoom");
list.add("alarm");
list.add("stop");
modelABuilder.setList(list);
return (ModelA) modelABuilder.getModel();
public ModelA getModelA3()
list.clear();
list.add("alarm");
list.add("start");
list.add("engineBoom");
list.add("stop");
modelABuilder.setList(list);
return (ModelA) modelABuilder.getModel();
//同理还可以封装更多......
3.建造者模式应用场景
1. 何时使用
一个基本部件不会变，而其组合经常变化的时候
2. 优点
- 封装性。是客户端不必知道产品内部组成的细节。
- 建造者独立，易扩展。
- 便于控制细节风险。可以对建造过程逐步细化，而不对其他模块产生任何影响。
3. 缺点
- 产品必须有共同点，范围有限制。
- 如果内部变化复杂，会有很多建造类。
4. 使用场景
相同的方法，不同的执行顺序，产生不同的事件结果时。
需要生成的对象具有复杂的内部结构时。
多个部件或零件，都可以装配到一个对象中，但产生的结果又不相同时。
5. 与工厂模式的区别
建造者模式更关注于零件装配的顺序,建造者模式一般和模板方法模式一起配合使用
以上是关于什么是建造者模式的主要内容，如果未能解决你的问题，请参考以下文章