创建者模式

创建者模式

概念

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

适用情况：
一个对象的构建比较复杂，将一个对象的构建(?)和对象的表示(?)进行分离。

• 对象的构建：对象进行各部件生产和组装的过程，表现为具体工厂生产具体产品的函数。

• 对象的表示：变现为一个具体的产品类。

角色及职责

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

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

3. Director：
   构造一个使用Builder接口的对象。扮演导演和总指挥的角色，指挥抽象工厂生产产品，而由于多态，抽象工厂实际使用的是具体工厂对象的构建方法。决定了各部件之间的生产和组装逻辑！

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