【设计模式学习笔记六】【创建型模式】【建造者模式(Builder)】

本文是我学习刘伟技术博客的笔记，博客链接如下：

http://blog.csdn.net/lovelion/article/details/17517213

我做的这部分笔记，鉴于自身水平有限，我只是对上面博客内做进一步提炼和记录，方便自己查阅。同时，更多的是对设计模式的框架进行学习，大部分细节都将略去，让自己侧重对每个设计模式框架的理解。

我应该理解和掌握的：

1）能够画出这个设计模式的架构框图；

2）能够根据架构框图写出对应的伪代码；

3）这个模式的应用场景，主要优缺点。

1.建造者模式

建造者模式是较为复杂的创建型模式，他将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离，客户端无需知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。

（1）定义

建造者模式：将一个复杂对象的构建和他的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建他们，用户不需要知道内部的具体构建细节。

建造者模式结构图：

参与者：

1）Builder(抽象建造者)：它为创建一个产品Product对象的各个部件指定抽象接口。

2）ConceteBuilder(具体建造者)：实现Builder接口，实现各个部件的具体构造和装配方法。

3）Product(产品角色)：它是被构建的复杂对象，包含多个组件，属性；具体建造者创建该产品的内部表示并定义他的装配过程。

4）Director(指挥者)：负责安排复杂对象的构造次序，与建造泽关联。

所谓的复杂对象是指那些包含多个成员属性的对象，这些成员属性也称为部件或零件。

主要的作用是，我们随时可以更换builer,不同的建造者创建不同属性的Product,所以客户端只需要更换builder就可以创建不同的产品，同时也符合开闭原则。

看图写代码：

class Producr
{
public:
    Producr();
    ~Producr();
    void setPartA(int a);
    void setPartB(int b);
    void setPartC(int c);
private:
    int partA;
    int partB;
    int partC;
};
Producr::Producr()
{
}
Producr::~Producr()
{}
void Producr::setPartA(int a)
{
    partA = a;
}
void Producr::setPartB(int b)
{
    partB = b;
}
void Producr::setPartC(int c)
{
    partC = c;
}
class Builder
{
public:
    /*抽象建造者，声明一系列部件的方法，由子类实现*/
    virtual void createProducr() = 0;
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual void buildPartC() = 0;
    virtual Producr* getResult() = 0;
};
class ConcreteBuilder:piubli Builder{
public:
    ConcreteBuilder();
    ~ConcreteBuilder();
    //create a product
    void createProducr();
    //build the para of product
    void buildPartA();
    void buildPartB();
    void buildPartC();
    //return a product
    Producr* getResult();
private:
    Producr* m_product;
};
ConcreteBuilder::ConcreteBuilder()
{}
ConcreteBuilder::~ConcreteBuild()
{}
/*通过调用产品本身的方法设置属性*/
void ConcreteBuilder::createProducr()
{
    m_product = new Producr();
}
void ConcreteBuilder::buildPartA()
{
    cout<<"build product partA";
    m_product->setPartA(1);
}
void ConcreteBuilder::buildPartB()
{
    cout<<"build product partB";
    m_product->setPartB(2);
}
void ConcreteBuilder::buildPartC()
{
    cout<<"build product partC";
    m_product->setPartC(3);
}
Producr* ConcreteBuilder::getResult()
{
    return m_product;
}
/*作用一是隔离了客户与创建过程
 二是控制产品的创建过程，方法是否需要调用，次序等
 这些客户无需了解，只需要知道具体建造者就可以了。
 */
class Director
{
public:
    Director(Builder builder);//注入builder
    ~Director();
    
    void setBuiler(Builder* b);
    Producr* contruct(Builder builder);
private:
    Builder builer;
};
Director::Director(Builder builder)
{
    this.builder = builder;
}
Director::~Director()
{}

void Director::setBuiler(Builder* b)
{
    this.builder = b;
}
Producr* Director::contruct()
{
    if(!builder)
        return;
    builder->createBuiler();
    builder->buildPartA();
    builder->buildPartB();
    builder->buildPartC();
    return builder->getResult();
}
int main()
{
    Builder builder = new ConceteBuilder();
    Director dt = new Director(builer);
    Producr* pd = dt->contruct();
    return 0;
}

（2）总结

1）客户端不需要知道内部组成细节，实现产品本身与产品的创建过程的解耦，使相同的创建过程可以创建不同的产品。

2）每一个建造者都相对独立，可以替换或增加新的具体建造者，得到不同的产品。指挥者类针对抽象编程，不必修改原有代码，易扩展，符合开闭。

3）可以更加精细的控制产品的创建过程。

（3）适用场景

1）需要生成的产品有复杂的内部结构，通常指包含多个成员属性的对象。

2）需要生成的产品对象的属性相互依赖，需要指定其生成顺序。

3）将创建过程封装在指挥者类中，对象的创建独立于创建该对象的类。

4）隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。