大话设计模式13----建造者模式

大话设计模式

1 建造模式（Builder）结构图

2 对建造者模式的一些解释

2.1 概念：将一个复杂对象的构造与它的表示分离，使得同样的构造过程可以创建不同的表示。【DP】

2.2 角色扮演：

Builder：是为创建一个Product对象的各个部件指定的抽象接口；
ConcreteBuilder：是具体创建者，实现Builder接口，构造和装配各个部件；
Product：具体的产品角色；
Director：指挥者，他是构建一个使用Builder接口的对象。
2.3 建造者模式主要用于创建一些复杂的对象，这些对象内部构建间的顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化；建造者模式的好处就是使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

2.4 使用场景：当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时使用。

3 建造者模式C++代码实现

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Product
{
private:
vector<string> parts;

public:
//添加新产品部件
void Add(string part)
{
parts.push_back(part);
}

//列举所有的产品部件
void Show()
{
cout << "\n产品 创建------" << endl;
for (auto it = parts.cbegin(); it != parts.cend(); ++it)
{
cout << *it << endl;
}
}
};

//抽象建造者类
class Builder
{
public:
virtual void BuildPartA()
{
cout << "创造者A" << endl;
}
virtual void BuildPartB()
{
cout << "创造者A" << endl;
}
virtual Product *GetResult()
{
cout << "返回结果" << endl;
return new Product();
}
};

//具体建造者类A
class ConcreteBuilder1 :public Builder
{
private:
Product *pro;

public:
ConcreteBuilder1()
{
pro = new Product();
}

~ConcreteBuilder1()
{
delete pro;
pro = nullptr;
}

void BuildPartA() override
{
pro->Add("部件A");
}

void BuildPartB() override
{
pro->Add("部件B");
}

Product *GetResult() override
{
return pro;
}
};

//具体建造者类B
class ConcreteBuilder2 :public Builder
{
private:
Product *pro;

public:
ConcreteBuilder2()
{
pro = new Product();
}

~ConcreteBuilder2()
{
delete pro;
pro = nullptr;
}

void BuildPartA() override
{
pro->Add("部件X");
}

void BuildPartB() override
{
pro->Add("部件Y");
}

Product *GetResult() override
{
return pro;
}
};

//指挥者类
class Director
{
public:
//用来只会创建的过程
void Construct(Builder *builder)
{
builder->BuildPartA();
builder->BuildPartB();
}
};

int main()
{
Director *dir = new Director();

ConcreteBuilder1 *conBu1 = new ConcreteBuilder1();
ConcreteBuilder2 *conBu2 = new ConcreteBuilder2();

//指挥者用ConcreteBuilder1来创建
dir->Construct(conBu1);
Product *pro1 = conBu1->GetResult();
pro1->Show();
cout << endl;

//指挥者用ConcreteBuilder2来创建
dir->Construct(conBu2);
Product *pro2 = conBu2->GetResult();
pro2->Show();
cout << endl;

delete dir;
delete conBu1;
delete conBu2;

system("pause");
return 0;
}

运行结果：

产品 创建------
部件A
部件B

产品 创建------
部件X
部件Y

请按任意键继续. . .

以下内容引自<http://blog.csdn.net/zhengzhb/article/details/7375966>，转载请注明出处！！！

卡奴达摩----建造者模式

定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

类型：创建类模式

类图：





四个要素：
产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。
抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。
导演类：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变的部分。

代码实现：

class Product {
private String name;
private String type;
public void showProduct(){
System.out.println("名称："+name);
System.out.println("型号："+type);
}
public void setName(String name) {
this.name = name;
}
public void setType(String type) {
this.type = type;
}
}

abstract class Builder {
public abstract void setPart(String arg1, String arg2);
public abstract Product getProduct();
}
class ConcreteBuilder extends Builder {
private Product product = new Product();

public Product getProduct() {
return product;
}

public void setPart(String arg1, String arg2) {
product.setName(arg1);
product.setType(arg2);
}
}

public class Director {
private Builder builder = new ConcreteBuilder();
public Product getAProduct(){
builder.setPart("宝马汽车","X7");
return builder.getProduct();
}
public Product getBProduct(){
builder.setPart("奥迪汽车","Q5");
return builder.getProduct();
}
}
public class Client {
public static void main(String[] args){
Director director = new Director();
Product product1 = director.getAProduct();
product1.showProduct();

Product product2 = director.getBProduct();
product2.showProduct();
}
}

建造者模式的优点：
首先，建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。

建造者模式与工厂模式的区别：
我们可以看到，建造者模式与工厂模式是极为相似的，总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。
与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。

总结

建造者模式与工厂模式类似，他们都是建造者模式，适用的场景也很相似。一般来说，如果产品的建造很复杂，那么请用工厂模式；如果产品的建造更复杂，那么请用建造者模式。