建造者模式
定义: 也叫生成器模式,将一个复杂的对象的构建与他的表示分离,使得同样的构建过程可以创建不同的表示。
如果有多个产品类就有几个具体的建造者,而且这多个产品类具有相同的接口或抽象类。
导演类起到封装作用,当建造者模式比较大时,导演类可以有多个。
类图:
Product产品类:
通常实现了模板方法模式,也就是有模板方法和基本方法.
Builder抽象建造者:
规范产品的组建,一般由子类实现。
ConcreteBulider具体建造者:
实现抽象类的定义的所有方法,并返回一个组建好的对象。
Director 指导类:
负责安排已有模块的顺序,然后调用Bulider开始建造。
建造者优点:
1).客户端不必知道内部实现
2).建造者独立,容易扩展
3).具体见到这是独立的,可以对建造过程逐步细化,而不对其他模块产生影响。
使用场景:
1).相同方法,不同执行顺序,产生不同的事件结果。
2).多个部件或零件,都可以装配到一个对象中,但是产生的运行结果又不相同
3).产品类非常复杂,或者产品类的调用顺序不同产生不同的效能
4).对象使用过程中会使用到系统中的其他对象
建造者模式扩展:
对建造者模式引入模板方法模式
建造者模式与工厂模式:
建造者模式 工厂模式
主要注重调用基本方法的顺序安排,也就是基本方法实现了,也就是零件的装配,顺序不同产生的对象也不同,(顺序不同产生对象不同) 主要重点是创建,创建零件是他的职责,组装顺序不关心
题示:
宝马车奔驰车模型用户随时可能要求更改 指导类只制造了四个模型
代码:
#include <iostream>
#include <vector>
#include <string>
using namespace std;
typedef vector<string> ArrayList;
//车辆模型抽象类
class CarModel
{
private:
ArrayList sequence = ArrayList();
protected:
virtual void start() = 0;
virtual void stop() = 0;
virtual void alarm() = 0;
virtual void engineBoom() = 0;
public :
virtual void run() final
{
for(unsigned int i = 0 ; i <sequence.size(); i++)
{
string actionName = sequence[i];
if(actionName == "start")
this->start();
if(actionName == "stop")
this->stop();
if(actionName == "alarm")
this->alarm();
if(actionName == "engine Boom")
this->engineBoom();
}
}
public:
virtual void setSequence(ArrayList sequence) final
{
this->sequence = sequence;
}
};
//奔驰模型
class BenzModel:public CarModel
{
protected:
void alarm()
{
cout<<"奔驰车的喇叭声是这样的"<<endl;
}
void engineBoom()
{
cout<<"奔驰车的引擎是这个声音"<<endl;
}
void start()
{
cout<<"奔驰车跑起来是这个声音"<<endl;
}
void stop()
{
cout<<"奔驰车应该是这样停车的"<<endl;
}
};
//宝马模型
class BMWModel:public CarModel
{
protected:
void alarm()
{
cout<<"宝马车的喇叭声是这样的"<<endl;
}
void engineBoom()
{
cout<<"宝马车的引擎是这个声音"<<endl;
}
void start()
{
cout<<"宝马车跑起来是这个声音"<<endl;
}
void stop()
{
cout<<"宝马车应该是这样停车的"<<endl;
}
};
//抽象汽车组装者
class CarBuilder
{
public:
virtual void setSequence(ArrayList sequence) = 0;//建造模型 要给组装顺序
virtual CarModel* getCarModel() = 0 ;//顺序设置完毕,就可以拿到这个车辆模型
};
//奔驰组装者
class BenzBuilder : public CarBuilder
{
private:
BenzModel benz = BenzModel();
public:
CarModel* getCarModel()
{
return &(this->benz);
}
void setSequence(ArrayList sequence)
{
this->benz.setSequence(sequence);
}
};
//宝马组装者
class BMWBuilder : public CarBuilder
{
private:
BMWModel bmw = BMWModel();
public:
CarModel* getCarModel()
{
return &(this->bmw);
}
void setSequence(ArrayList sequence)
{
this->bmw.setSequence(sequence);
}
};
//导演类 只制造了4个模型
class Director
{
private :
ArrayList sequence = ArrayList();
BenzBuilder benzbuilder = BenzBuilder();
BMWBuilder bmwbuilder = BMWBuilder();
/*四个模型*/
public:
BenzModel getABenzModel()
{
/*清理现场*/
this->sequence.clear();
this->sequence.push_back("start");
this->sequence.push_back("stop");
this->benzbuilder.setSequence(this->sequence);
CarModel * car(this->benzbuilder.getCarModel());
return *(dynamic_cast<BenzModel*>(car));
}
BenzModel getBBenzModel()
{
/*清理现场*/
this->sequence.clear();
this->sequence.push_back("engine boom");
this->sequence.push_back("start");
this->sequence.push_back("stop");
this->benzbuilder.setSequence(this->sequence);
CarModel * car(this->benzbuilder.getCarModel());
return *(dynamic_cast<BenzModel*>(car));
}
BMWModel getCBMWModel()
{
/*清理现场*/
this->sequence.clear();
this->sequence.push_back("alarm");
this->sequence.push_back("start");
this->sequence.push_back("stop");
this->bmwbuilder.setSequence(this->sequence);
CarModel * car(this->bmwbuilder.getCarModel());
return *(dynamic_cast<BMWModel*>(car));
}
BMWModel getDBMWModel()
{
/*清理现场*/
this->sequence.clear();
this->sequence.push_back("alarm");
this->sequence.push_back("start");
this->bmwbuilder.setSequence(this->sequence);
CarModel * car(this->bmwbuilder.getCarModel());
return *(dynamic_cast<BMWModel*>(car));
}
};
int main()
{
Director dircetor = Director();
//2俩A类型奔驰车
for(int i = 0 ; i < 2 ; i++)
{
dircetor.getABenzModel().run();
}
for(int i = 0 ; i < 2 ; i++)
{
dircetor.getCBMWModel().run();
}
return 0;
return 0;
}
结果:
奔驰车跑起来是这个声音
奔驰车应该是这样停车的
奔驰车跑起来是这个声音
奔驰车应该是这样停车的
宝马车的喇叭声是这样的
宝马车跑起来是这个声音
宝马车应该是这样停车的
宝马车的喇叭声是这样的
宝马车跑起来是这个声音
宝马车应该是这样停车的