设计模式之建造者模式

建造者模式

题外话：面向对象的一个重要指导思想就是，封装隔离变化的，留出不变的。

特点：一个对象的构建比较复杂，则将对象的构建和对象的表示（要被创建的产品）进行分离。

角色：

Product：所要构建的复杂对象。

Builder：定义创建对象过程的抽象，提供构建不同组成部分的抽象接口。他和产品之间的关系是关联，即拥有一个产品属性的成员变量。

ConcreteBuilder：具体实现Builder中的各个构建子函数。不同的ConcreteBuilder可能有不同的实现方式。

Director：规定对象构建的业务逻辑，即构建步骤的顺序。这里Director聚合了Builder类的指针.

//构建房子：房子本身，工程队，设计师

class House{
public:
	void setDoor(string dor){
		door=dor;
	}
	void setWindow(string win){
		window=win;
	}
	void setWall(string wa){
		wall=wa;
	}
	string getDoor(){
		cout<<door<<endl;
		return door;
	}
	string getWall(){
		cout<<wall<<endl;
		return wall;
	}
	string getWindow(){
		cout<<window<<endl;
		return window;
	}
private:
	string door;
	string window;
	string wall;
};
class Builder{
public:
	virtual void makeDoor()=0;
	virtual void makeWindow()=0;
	virtual void makeWall()=0;
	virtual House* getHouse()=0;
};

class flatBuilder:public Builder{
public:
	flatBuilder(){
		m_hou=new House;
	}
	void makeDoor(){
		m_hou->setDoor("flat door");
	}
	void makeWindow(){
			m_hou->setWindow("flat window");
	}
	void makeWall(){
			m_hou->setWall("flat wall");
	}
	House* getHouse(){
		return m_hou;
	};

private:
House* m_hou;
};
class villaBuilder:public Builder{
public:
	villaBuilder(){
		m_hou=new House;
	}
	void makeDoor(){
		m_hou->setDoor("villa door");
	}
	void makeWindow(){
			m_hou->setWindow("villa window");
	}
	void makeWall(){
			m_hou->setWall("villa wall");
	}
	House* getHouse(){
		return m_hou;
	};

private:
House* m_hou;
};

class Designer{
public:
	Designer(Builder* bur):m_bur(bur){}
	void makeHouse(){
		m_bur->makeDoor();
		m_bur->makeWall();
		m_bur->makeWindow();
	}
private:
Builder* m_bur;
};

int main(){
	Builder* build=new villaBuilder;
	//Builder* build=new flatBuilder;
	Designer* des= new Designer(build);
	des->makeHouse();
	House* house=build->getHouse();
	house->getDoor();
	house->getWall();
	house->getWindow();
	return 0;
}