设计模式---5（建造者模式的概念及其实现，建造者模式的角色与职责，建造者模式和工厂模式的区别）

建造者模式

建造者模式的概念

1. Builder 模式也叫建造者模式或者生成器模式，是由 GoF 提出的 23 种设计模式中的一种。 Builder 模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的 创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。
2. 对象的创建：Builder 模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：不同的工厂 （这里指 builder 生成器）对产品属性有不同的创建方法

建造者模式的角色和职责

1. 建造者（Builder）：为创建产品各个部分，统一抽象接口。
2. ConcreteBuilder：具体的创建产品的各个部分，部分 A， 部分 B，部分 C。
3. 设计师（Director）：构造一个使用 Builder 接口的对象。
4. Product：表示被构造的复杂对象。

ConcreteBuilder 创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类， 包括将这些部件装配成最终产品的接口。

建造者模式的适用情况

一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离。

建造者模式的实现

#include<iostream>
#include<string>

using namespace std;

//一个房子不管是公寓还是别墅，他都有三种属性，墙，地板，门
//建造公寓和别墅时，都需要建造者有房子的图纸

//房子类
class House
{
public:
	//创建地板
	void setFloor(string floor)
	{
		this->m_floor = floor;
	}
	//创建墙
	void setWall(string wall)
	{
		this->m_wall = wall;
	}
	//创建门
	void setdoor(string door )
	{
		this->m_door = door;
	}
	//获取地板
	string getFloor()
	{
		return m_floor;
	}
	//获取墙
	string getWall()
	{
		return m_wall;
	}
	//获取门
	string getDoor()
	{
		return m_door;
	}
private:
	string m_floor;//地板
	string m_wall;//墙
	string m_door;//门
};

//建造者
class Builder
{
public:
	virtual void makeFloor() = 0; //建造者建地板
	virtual void makeWall() = 0;	//建造者建墙
	virtual void makeDoor() = 0; //建造者建门
	virtual House *GetHouse() = 0; //建造者建房子
};

//建造者建造公寓 继承建造者类
class FlatBuild : public Builder
{
public:
	FlatBuild()
	{
		phouse = new House;//创建一个新的房子
	}
	virtual void makeFloor()
	{
		//这个房子的墙是公寓的地板
		phouse->setFloor("公寓的地板");
	}
	virtual void makeWall()
	{
		phouse->setWall("公寓的墙");
	}

	virtual void makeDoor()
	{
		phouse->setdoor("公寓的门");
	}

	virtual House *GetHouse()
	{
		return phouse;
	}
private:
	House *phouse; //维护一个房子类的指针
};

//建造者建造别墅 
class VillBuild :public Builder
{
public:
	VillBuild()
	{
		pHouse = new House;
	}
	virtual void makeFloor()
	{
		pHouse->setFloor("别墅的地板");
	}
	virtual void makeWall()
	{
		pHouse->setWall("别墅的墙");
	}
	virtual void makeDoor()
	{
		pHouse->setdoor("别墅的门");
	}
	virtual House *GetHouse()
	{
		return pHouse;
	}
private:
	House *pHouse;
};

//设计师类，用来指挥建造者
class Director
{
public:
	void Construct(Builder *builder)
	{
		builder->makeFloor();
		builder->makeWall();
		builder->makeDoor();
	}
};

int main(void)
{
	//客户自造房子，不花钱请建造者和设计师
	House *phouse = new House;
	phouse->setdoor("自己造的门");
	phouse->setFloor("自己造的地板");
	phouse->setWall("自己造的墙");
	cout << phouse->getDoor() << endl;
	cout << phouse->getWall() << endl;
	cout << phouse->getFloor() << endl;
	/*
	//建造者直接造公寓，不花钱请设计师
	Builder *builder = new FlatBuild;
	builder->makeFloor();
	builder->makeDoor();
	builder->makeWall();
	*/

	//设计师指挥	建造者	建房子
	Director *director = new Director;

	//建公寓
	Builder *builder = new FlatBuild;
	director->Construct(builder);//设计师指挥建造者干活,直接全部建好
	House*house = builder->GetHouse();//获取已经建好房子的钥匙
	cout << house->getFloor() << endl;//查看建好房子的地板
	delete house;
	delete builder;
	
	//建别墅
	builder = new VillBuild;
	director->Construct(builder);//设计师 指挥工程队  建好别墅
	house = builder->GetHouse();//从建造者那块拿到别墅的钥匙
	cout << house->getFloor() << endl;//查看建好的别墅的地板

	delete house;
	delete builder;
	delete director;

	system("pause");
	return 0;
}

建造者模式和工厂模式的区别

Factory 模式中：

1. 有一个抽象的工厂。
2. 实现一个具体的工厂—汽车工厂。
3. 工厂生产汽车 A，得到汽车产品 A。
4. 工厂生产汽车 B，得到汽车产品 B。 这样做，实现了购买者和生产线的隔离。强调的是结果。

Builder 模式:

1. 引擎工厂生产引擎产品，得到汽车部件 A。
2. 轮胎工厂生产轮子产品，得到汽车部件 B。
3. 底盘工厂生产车身产品，得到汽车部件 C。
4. 将这些部件放到一起，形成刚好能够组装成一辆汽车的整体。
5. 将这个整体送到汽车组装工厂，得到一个汽车产品。

总结

这样做，目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程 两者的区别在于：

1. Factory 模式不考虑对象的组装过程，而直接生成一个我想要的对象。
2. Builder 模式先一个个的创建对象的每一个部件，再统一组装成一个对象。
3. Factory 模式所解决的问题是，工厂生产产品。
4. 而 Builder 模式所解决的问题是工厂控制产品生成器组装各个部件的过程，然后从产品 生成器中得到产品。