创建者模式
概念
建造者模式也叫生成器模式,是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式,用来隐藏复合对象的创建过程,它把复合对象的创建过程加以抽象,通过子类继承和重载的方式,动态地创建具有复合属性的对象。
对象的创建:Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象:关注对象各部分的创建过程:不同的工厂(这里指builder(创建者)/生成器)对产品属性有不同的创建方法。
适用情况:
一个对象的构建比较复杂,将一个对象的构建(?)和对象的表示(?)进行分离。
对象的构建:对象进行各部件生产和组装的过程,表现为具体工厂生产具体产品的函数。
对象的表示:变现为一个具体的产品类。
角色及职责
Builder:
为创建产品各个部分,统一抽象接口。ConcreteBuilder:
具体的创建产品的各个部分,部分A, 部分B,部分C。Director:
构造一个使用Builder接口的对象。扮演导演和总指挥的角色,指挥抽象工厂生产产品,而由于多态,抽象工厂实际使用的是具体工厂对象的构建方法。决定了各部件之间的生产和组装逻辑!Product:
表示被构造的复杂对象。里面有多个部件,需要在ConcreteBuilder里面单独进行生产和组装。
ConcreteBuilder创建该产品的内部表示并定义它的装配过程,包含定义组成部件的类,包括将这些部件装配成最终产品的接口。
和工厂方法模式的区别
Factory模式中:
1、有一个抽象的工厂。
2、实现一个具体的工厂—汽车工厂。
3、工厂生产汽车A,得到汽车产品A。
4、工厂生产汽车B,得到汽车产品B。
这样做,实现了购买者和生产线的隔离。强调的是结果。Builder模式:
1、引擎工厂生产引擎产品,得到汽车部件A。
2、轮胎工厂生产轮子产品,得到汽车部件B。
3、底盘工厂生产车身产品,得到汽车部件C。
4、将这些部件放到一起,形成刚好能够组装成一辆汽车的整体。
5、将这个整体送到汽车组装工厂,得到一个汽车产品。
这样做,目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程两者的区别在于:
- Factory模式不考虑对象的组装过程,而直接生成一个我想要的对象。
- Builder模式先一个个的创建对象的每一个部件,再统一组装成一个对象。
Factory模式所解决的问题是,工厂生产产品。
而Builder模式所解决的问题是工厂控制产品生成器组装各个部件的过程,然后从产品生成器中得到产品。Builder模式不是很常用。
案例
#include<iostream>
using namespace std;
/*对象的表示*/
class House
{
public:
void setDoor(string door)
{
this->m_door = door;
}
void setWall(string wall)
{
this->m_wall = wall;
}
void setWindow(string window)
{
this->m_window = window;
}
//--
string getDoor( )
{
cout << m_door << endl;
return this->m_door ;
}
string getWall()
{
cout << m_wall << endl;
return this->m_wall;
}
string getWindow()
{
cout << m_window << endl;
return m_window;
}
private:
string m_door;
string m_wall;
string m_window;
};
/*对象的构建--抽象接口--建筑团队--干具体的活--被设计师调用指挥*/
class Builder
{
public:
virtual void buildWall()=0;
virtual void buildDoor()=0;
virtual void buildWindow()=0;
virtual House* getHouse()=0;
};
/*对象的构建1--实现所有组件的构建功能--具体的构建者*/
class FlatBuilder:public Builder
{
public:
FlatBuilder()
{
m_house = new House;
}
virtual void buildWall()
{
m_house->setWall("flat wall");
}
virtual void buildDoor()
{
m_house->setDoor("flat door");
}
virtual void buildWindow()
{
m_house->setWindow("flat window");
}
virtual House* getHouse()
{
return m_house;
}
private:
House* m_house;
};
/*对象的构建2--实现所有组件的构建功能--具体的构建者*/
class VillaBuilder:public Builder
{
public:
VillaBuilder()
{
m_house = new House;
}
virtual void buildWall()
{
m_house->setWall("villa wall");
}
virtual void buildDoor()
{
m_house->setDoor("villa door");
}
virtual void buildWindow()
{
m_house->setWindow("villa window");
}
virtual House* getHouse()
{
return m_house;
}
private:
House* m_house;
};
/*设计师--负责建造逻辑(对象如何构建,构建顺序如何都与对象的表示无关)
* --指挥抽象的构建者--建筑团队
实现了对象的构建和对象的表示之间的解耦合(分离)*/
class Director
{
public:
Director(Builder* builder)
{
m_build = builder;
}
void Constructor()
{
m_build->buildWall();
m_build->buildWindow();
m_build->buildDoor();
}
private:
Builder * m_build;
};
/*测试案例*/
int main262()
{
/*请一个建筑团队--抽象构建者*/
Builder * builder = new VillaBuilder;//具体构建者
/*设计师指挥建筑团队干活--设计师--对象的构建*/
Director * director = new Director(builder);//指挥(依赖)抽象构建者
director->Constructor();//构建对象
/*具体产品--对象的表示*/
House * house = builder->getHouse();
/*展示对象*/
house->getDoor();
house->getWall();
house->getWindow();
delete house;//内存回收
delete builder;
builder = new FlatBuilder;//更换具体构建者
director = new Director(builder);//再次指挥(新的)抽象构建者
director->Constructor();//构建对象
/*对象的表示*/
house = builder->getHouse();
house->getDoor();
house->getWall();
house->getWindow();
delete house;
delete builder;
delete director;//内存回收
return 0;
}