建造者模式

在GOF的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

这句话，似懂非懂的。一个复杂对象的创建，其通常是由很多的子对象构成；如果一个对象能够直接就创建好了，那么也不会称之为复杂对象。由于项目中需求的变化，这个复杂对象的各个部分经常会发生剧烈的变化，但是，不管怎么变化，将它们组合在一起，组成一个复杂的对象的事实是不会变的。建造者模式就提供了一种“封装机制”来将各个对象的变化隔离开，最终，组合成复杂对象的过程是不会变的。

这也体现了设计模式的一个很重要的思想就是 ：封装不变的部分，隔离变化的部分。

在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为六步：头部、身体、左手、右手、左脚和右脚。与抽象工厂模式不同的是，建造者模式是在Director的控制下一步一步的构造出来的，在建造的过程中，建造者模式可以进行更精细的控制。不管人的头部、身体、左手、右手、左脚或者右脚如何变化，但是最终还是由这几部分组合在一起形成一个人，虽然是同一个建造过程，但是这个人就会有不同的表示，比如，胖子，瘦子，个高的，个低的等等。

#include <iostream>
using namespace std;

enum ManType
{
    Fatman,
    Thinman,
    Normalman
};

class Man{
private:
    ManType m_type;
public:
    void SetHead(ManType type) { m_type = type; }
    void SetBody(ManType type) { m_type = type; }
    void ShowMan() {
        switch (m_type) {
        case Fatman:
            cout << "fat man" << endl;
            break;
        case Thinman:
            cout << "fat man" << endl;
            break;
        case Normalman:
            cout << "normal man" << endl;
        default:
            return;
        }
        return;
    }
};

class Build {
public:
    virtual void BuildHead(){}
    virtual void BuildBody(){}
    virtual Man * GetMan() { return NULL; }
};

class FatMenBuild :public Build {
private:
    Man * m_FatMan;
public:
    FatMenBuild() {m_FatMan = new Man();}
    void BuildHead(){
        m_FatMan->SetHead(Fatman);
    }

    void BuildBody() {
        m_FatMan->SetBody(Fatman);
    }

    Man * GetMan() { return m_FatMan; }
};

class ThinMenBuild :public Build {
private:
    Man * m_thinMan;
public:
    ThinMenBuild() { m_thinMan = new Man(); }
    void BuildHead() {
        m_thinMan->SetHead(Thinman);
    }
    void BuildBody() {
        m_thinMan->SetBody(Thinman);
    }

    Man * GetMan() { return m_thinMan; }
};

class Director {
public:
    Director(Build * Builder) { m_Builder = Builder; }
    void CreateMan() {
        m_Builder->BuildHead();
        m_Builder->BuildHead();
    }
private:
    Build * m_Builder;
};

int main() {
    //step 1:
    Build * buildobj = new FatMenBuild();
    //step 2:
    Director directorobj(buildobj);
    //step 3:
    directorobj.CreateMan();
    
    //step 4:
    Man * manobj = buildobj->GetMan();
    if (manobj == NULL) {
        return 0;
    }

    manobj->ShowMan();

    delete manobj;
    manobj = NULL;

    delete buildobj;
    buildobj = NULL;


    system("pause");
    return 0;
}

jellythinkBuilderPatternSequence.png

使用要点 :

<ul>
<li>建造者模式生成的对象有复杂的内部结构，将分步骤的去构建一个复杂的对象，分多少步是确定的，而每一步的实现是不同的，可能经常发生变化；</li>
<li>在上面的例子中，我们都看到了最终生成的Man和Product都没有抽象类，这又导出建造者适用的一种情况，当需要创建复杂对象的过程中，复杂对象没有多少共同的特点，很难抽象出来时，而复杂对象的组装又有一定的相似点时，建造者模式就可以发挥出作用。简单的说，可能使用了建造者模式，最终建造的对象可能没有多大的关系，关于这一点，阅读《设计模式 可复用面向对象软件的基础》中的建造者模式时是最有体会的。</li>
</ul>

小结：

一个复杂对象是由多个部件组成的，建造者模式是把复杂对象的创建和部件的创建分别开来，分别用Builder类和Director类来表示。用Director构建最后的复杂对象，而在上面Builder接口中封装的是如何创建一个个部件（复杂对象是由这些部件组成的），也就是说，Director负责如何将部件最后组装成产品。这样建造者模式就让设计和实现解耦了。