设计模式之建造者模式

建造者模式

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



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

角色：

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;
}