建造者模式,属于创建性设计模式。其适用范围为:
1. 在项目中创建过程复杂
2. 会被重复使用来创建不同的对象。
当满足这两个条件的时候,便可以使用建造者模式。那么问题来了,什么是建造者模式呢?一开始可能会将抽象工厂方法和建造者模式混淆,下面我举一个简单的实例来说明建造者模式。
总所周知,大众旗下有很多不同的车型,所有的车子的组装大体上都一致,由发动机,轮胎,车身等组成,不同的车型的组装流程都一致,如果为每一个车型都单独设计一个组装流程,管理的成本就增加了,这个时候如果又有一个新的车型,那不是又的为这个新的车型设计一个新的组装流程?扩展性不好。这个时候,建造者模式就出现了,为所有的车型定一个统一的组装流程,所有的车型的组装都按照这个流程来组装。示例如下:
//car属性类
class Car
{
public:
void setEngine(string engine){ m_Engine = engine;}
void setWheel(string wheel){ m_Wheel = wheel;}
void setBody(string body){ m_Body = body;}
void disPlay(){ }
private:
string m_Engine;
string m_Wheel;
string m_Body;
};
//建造者模式抽象类,组装流程
class Assemble{
public:
virtual void assembleEngine(){};
virtual void assembleWheel(){};
virtual void assembleBody(){};
virtual Car* getCar(){ return nullptr;};
};
//a型车组装流程
class AssembleCarA : public Assemble
{
public:
AssembleCarA(){ _carA = new Car();}
virtual void assembleEngine( ){ _carA->setEngine("engineA");};
virtual void assembleWheel( ){ _carA->setWheel("whellA");}
virtual void assembleBody( ){ _carA->setBody("bodyA");};
virtual Car* getCar(){ return _carA; }
private:
Car *_carA;
};
//b型车组装流程
class AssembleCarB : public Assemble
{
public:
AssembleCarB(){ _carB = new Car();}
virtual void assembleEngine( ){ _carB->setEngine("engineB");};
virtual void assembleWheel( ){ _carB->setWheel("wheelB");}
virtual void assembleBody( ){ _carB->setBody("bodyB");};
virtual Car* getCar(){ return _carB; }
private:
Car *_carB;
};
//工厂类
class Factory{
public:
Factory(Assemble* assemble){ m_assemble = assemble;}
void assembleCar(){
m_assemble->assembleEngine();
m_assemble->assembleWheel();
m_assemble->assembleBody();
}
Car* getCar(){return m_assemble->getCar();}
private:
Assemble* m_assemble;
};
int main()
{
Assemble *m_assemble = new AssembleCarA();
Factory *m_factory = new Factory(m_assemble);
m_factory->assembleCar();
m_factory->getCar()->disPlay();
return 0;
}
上述示例中,将车子的组装流程统一为Assemble,具体的车型流程继承该类,来实现自己的零部件选择,最后统一又工厂类Factory统一来进行装配和管理,这样即使过程再复杂,也只需关心Assemble类,其他的对象只需实现该类的方法即可,这样就不需要为每个车型设计组装流程了。具体项目中,还需要大家视项目情况来进行设计。