建造者模式

概念

Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。

对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法

角色和职责

1) Builder：为创建产品各个部分，统一抽象接口。

2) ConcreteBuilder：具体的创建产品的各个部分，部分A， 部分B，部分C。

3) Director：构造一个使用Builder接口的对象。

4) Product：表示被构造的复杂对象。

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



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

Factory模式中：

1、有一个抽象的工厂。

2、实现一个具体的工厂—汽车工厂。

3、工厂生产汽车A，得到汽车产品A。

4、工厂生产汽车B，得到汽车产品B。

这样做，实现了购买者和生产线的隔离。强调的是结果。

Builder模式:

1、引擎工厂生产引擎产品，得到汽车部件A。

2、轮胎工厂生产轮子产品，得到汽车部件B。

3、底盘工厂生产车身产品，得到汽车部件C。

4、将这些部件放到一起，形成刚好能够组装成一辆汽车的整体。

5、将这个整体送到汽车组装工厂，得到一个汽车产品。

这样做，目的是为了实现复杂对象生产线和其部件的解耦。

案例

package pack;

class Product {
public void setA() {
System.out.println("set A OK");
}
public void setB() {
System.out.println("set B OK");
}
public void getA() {
System.out.println("part A show");
}
public void getB() {
System.out.println("part B show");
}
}

interface Builder {
public abstract void buildPartA();
public abstract void buildPartB();
public abstract Product getProduct();
}

class ConcreteBuilder implements Builder{
private Product product;
public ConcreteBuilder() {
product = new Product();
}
public void buildPartA() {
product.setA();
}
public void buildPartB() {
product.setB();
}
public Product getProduct() {
return product;
}
}

class Director {
public void direct(Builder builder) {
builder.buildPartA();
builder.buildPartB();
}
}

public class Mian {

public static void main(String[] args) {
Builder builder = new ConcreteBuilder(); //创建施工队
Director director = new Director();  //创建总指挥
director.direct(builder);  //总指挥指挥施工队干活
Product product = builder.getProduct(); //返回干活成果
product.getA();product.getB(); //成果展示

}
}

#include <iostream>
using namespace std;
#include "string"
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 setWall()
{
return  m_wall;
}
string setDoor()
{
return m_door;
}

protected:
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("flat Door");
}
virtual void makeWall()
{
pHouse->setWall("flat Wall");
}
virtual void makeDoor()
{
pHouse->setDoor("flat Door");
}
virtual House *GetHouse()
{
return pHouse;
}

private:
House *pHouse;
};

//别墅
class VillaBuild : public Builder
{
public:
VillaBuild()
{
pHouse = new House;
}
virtual void makeFloor()
{
pHouse->setFloor("villa floor");
}
virtual void makeWall()
{
pHouse->setWall("villa Wall");
}
virtual void makeDoor()
{
pHouse->setDoor("villa Door");
}
virtual House *GetHouse()
{
return pHouse;
}
private:
House *pHouse;
};

class Director
{
public:
void Construct(Builder *builder)
{
builder->makeFloor();
builder->makeWall();
builder->makeDoor();
}
protected:
private:
};

void main()
{
//客户直接造房子
House *pHose = new House;
pHose->setDoor("wbm门");
pHose->setFloor("wbmFloor");
pHose->setWall("wbmWall");
delete pHose;

/* //工程队直接造房子
Builder *builder = new FlatBuild;
builder->makeFloor();
builder->makeWall();
builder->makeDoor();
*/

//指挥者（设计师）指挥 工程队 和 建房子
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 VillaBuild;
director->Construct(builder); //设计师 指挥 工程队干活
house = builder->GetHouse();
cout << house->getFloor() << endl;
delete house;
delete builder;

delete director;

system("pause");
return ;
}