设计模式（创建型）之建造者模式

GOF 给建造模式的定义为：将一个复杂对象的构建与它的表示分离，使得同样的构建
过程可以创建不同的表示。即，将构造复杂对象的过程和组成对象的部件解耦。就像攒电脑一样，不管什么品牌的配件，只要兼容就可以装上；同样，一样的配件，可以有好多组装的方式。这是对降低耦合、提高可复用性精神的一种贯彻。

将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

当要生成的产品有复杂的内部结构——比如由多个对象组成；而系统中对此产品的需求
将来可能要改变产品对象的内部结构的构成，比如说产品的一些属性现在由一个小对象组
成，而更改后的型号可能需要N 个小对象组成；而且不能将产品的内部构造完全暴露给客
户程序，一是为了可用性，二是为了安全等因素。满足上面的设计环境就可以考虑使用建造
模式来搭建框架了。

1、组成：

        1) 抽象建造者角色：这个角色用来规范产品对象的各个组成成分的建造。一般而言，此角色独立于应用程序的业务逻辑。
        2) 具体建造者角色：担任这个角色的是于应用程序紧密相关的类，它们在指导者的调用下创建产品实例。这个角色在实现抽象建造者角色提供的方法的前提下，达到完成产品组装，提供成品的功能。
        3) 指导者角色：调用具体建造者角色以创建产品对象。指导者并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者对象。
        4) 产品角色：建造中的复杂对象。它要包含那些定义组件的类，包括将这些组件装配成产品的接口。

2、UML类图：

3、代码实现：

JAVA：

Builder.java:

// 抽象建造者角色

public abstract class Builder {
public abstract void BuildPartA();
public abstract void BuildPartB();
}

// 具体建造者角色

class ConcreateBuilder1 extends Builder {
public void BuildPartA(){
System.out.println("BuilderPartA by ConcreateBuilder1");
}
public void BuildPartB(){
System.out.println("BuilderPartB by ConcreateBuilder1");
}
}

// 具体建造者角色

class ConcreateBuilder2 extends Builder {
public void BuildPartA(){
System.out.println("BuilderPartA by ConcreateBuilder2");
}
public void BuildPartB(){
System.out.println("BuilderPartB by ConcreateBuilder2");
}
}

// 指导者角色

class Director {
private Builder m_builder;
public Director(Builder pBuilder){
  this.m_builder = pBuilder;
}
public void Construct(){
  m_builder.BuildPartA();
  m_builder.BuildPartB();
}
}

Main.cpp:

public class Main {

public static void main(String[] args) {
  ConcreateBuilder1 cb1 = new ConcreateBuilder1();
  ConcreateBuilder2 cb2 = new ConcreateBuilder2();
  Director dr1 = new Director(cb1);
  Director dr2 = new Director(cb2);
  dr1.Construct();
  dr2.Construct();
}
}

输出结果：

BuilderPartA by ConcreateBuilder1
BuilderPartB by ConcreateBuilder1
BuilderPartA by ConcreateBuilder2
BuilderPartB by ConcreateBuilder2

C++:

Builder.h:

#ifndef BUILDER_H

#define BUILDER_H

//　虚拟基类,是所有Builder的基类,提供不同部分的构建接口函数
class Builder
{
public :
Builder(){}
virtual ~ Builder(){}

//　纯虚函数,提供构建不同部分的构建接口函数
virtual void BuilderPartA() = 0;
virtual void BuilderPartB() = 0;
};

//　使用Builder构建产品,构建产品的过程都一致,但是不同的builder有不同的实现
//　这个不同的实现通过不同的Builder派生类来实现,存有一个Builder的指针,通过这个来实现多态调用
class Director
{
public:
Director(Builder * pBuilder);
~ Director();
void Construct();

private:
Builder * m_pBuilder;
};

//　 Builder的派生类,实现BuilderPartA和BuilderPartB接口函数
class ConcreateBuilder1 : public Builder
{
public:
ConcreateBuilder1() {}
virtual ~ ConcreateBuilder1() {}
virtual void BuilderPartA();
virtual void BuilderPartB();
};

//　 Builder的派生类,实现BuilderPartA和BuilderPartB接口函数
class ConcreateBuilder2 : public Builder
{
public:
ConcreateBuilder2() {}
virtual ~ ConcreateBuilder2() {}
virtual void BuilderPartA();
virtual void BuilderPartB();
};

#endif

Build.cpp:

#include "Builder.h"
#include <iostream>

void ConcreateBuilder1::BuilderPartA() {
std::cout << " BuilderPartA by ConcreateBuilder1n " << std::endl;
}

void ConcreateBuilder1::BuilderPartB() {
std::cout << " BuilderPartB by ConcreateBuilder1n " << std::endl;
}

void ConcreateBuilder2::BuilderPartA() {
std::cout << " BuilderPartA by ConcreateBuilder2n " << std::endl;
}

void ConcreateBuilder2::BuilderPartB() {
std::cout << " BuilderPartB by ConcreateBuilder2n " << std::endl;
}

Director::Director(Builder * pBuilder) : m_pBuilder(pBuilder){}

Director::~Director() {
delete m_pBuilder;
m_pBuilder = NULL;
}

//　 Construct函数表示一个对象的整个构建过程,不同的部分之间的装配方式都是一致的,
//　首先构建PartA其次是PartB,只是根据不同的构建者会有不同的表示
void Director::Construct() {
m_pBuilder->BuilderPartA();
m_pBuilder->BuilderPartB();
}

Main.cpp:

#include "Builder.h"
#include <stdlib.h>

int main(){
Builder * pBuilder1 = new ConcreateBuilder1();
Director * pDirector1 = new Director(pBuilder1);
pDirector1->Construct();

Builder * pBuilder2 = new ConcreateBuilder2();
Director * pDirector2 = new Director(pBuilder2);
pDirector2->Construct();

delete pDirector1;
delete pDirector2;

system(" pause ");

return 0;
}

输出结果：

BuilderPartA by ConcreateBuilder1n
BuilderPartB by ConcreateBuilder1n
BuilderPartA by ConcreateBuilder2n
BuilderPartB by ConcreateBuilder2n

        建造模式可以使得产品内部的表象独立变化。在原来的工厂方法模式中，产品内部的表象是由产品自身来决定的；而在建造模式中则是“外部化”为由建造者来负责。这样定义一个新的具体建造者角色就可以改变产品的内部表象，符合“开闭原则”。
        建造模式使得客户不需要知道太多产品内部的细节。它将复杂对象的组建和表示方式封装在一个具体的建造角色中，而且由指导者来协调建造者角色来得到具体的产品实例。
        每一个具体建造者角色是毫无关系的。
        建造模式可以对复杂产品的创建进行更加精细的控制。产品的组成是由指导者角色调用具体建造者角色来逐步完成的，所以比起其它创建型模式能更好的反映产品的构造过程。

建造模式在得到复杂产品的时候可能要引用多个不同的组件，在这一点上来看，建造模式和抽象工厂模式是相似的。可以从以下两点来区分两者：创建模式着重于逐步将组件装配成一个成品并向外提供成品，而抽象工厂模式着重于得到产品族中相关的多个产品对象；抽象工厂模式的应用是受限于产品族的（具体参见《深入浅出工厂模式》），建造模式则不会。

转载于:https://blog.51cto.com/flyingsnail/1227982

设计模式（创建型）之建造者模式

相关推荐