建造者模式
2020 年 08 月 27 日 230 759 字 暂无评论

01.概念

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

02.类图结构

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

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

具体内容和用处

  • 将一部负责对象的构建分为许多小对象的构建,最后在整合构建的模式。
  • 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

03.建造者模式案例

#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;
private:
};

//公寓
class  FlatBuild : public Builder
{
public:
        FlatBuild()
        {
                pHouse = new House;
        }
        virtual void makeFloor()
        {
                pHouse->setFloor("flat Floor");
        }
        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();
        }
private:
};


void main()
{
        //客户直接造房子
        House* pHouse = new House;
        pHouse->setFloor("zfh floor");
        pHouse->setWall("zfh wall");
        pHouse->setDoor("zfh door");
        cout << pHouse->getFloor() << endl;
        cout << pHouse->getWall() << endl;
        cout << pHouse->getDoor() << endl;
        delete pHouse;

        //工程队直接造房子
        Builder* builder = new FlatBuild;
        builder->makeFloor();
        builder->makeWall();
        builder->makeDoor();
        House* flathouse = builder->GetHouse();
        cout << flathouse->getFloor() << endl;
        cout << flathouse->getWall() << endl;
        cout << flathouse->getDoor() << endl;
        delete flathouse;
        delete builder;

        //指挥者 指挥工程队建房子
        Director* director = new Director;

        //建公寓
        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;
}
  • 输出
zfh floor
zfh wall
zfh door
flat Floor
flat Wall
flat Door
flat Floor
villa Floor

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

4.1 Factory模式

  1. 有一个抽象的工厂。
  2. 实现一个具体的工厂---汽车工厂。
  3. 工厂生产汽车A,得到汽车产品A。
  4. 工厂生产汽车B,得到汽车产品B。
  • 注意

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

4.2 Builder模式

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

    • 这样做,目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程

4.3 区别

  • 两者的区别在于:

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

版权属于:zfh

本文链接:http://zfhblog.com/index.php/archives/123/



评论已关闭