设计模式学习[11]---建造者模式

前言

建造者模式属于创建型模式，原型模式与工厂模式也归属于这一类。
创建型模式的特点在于，创建新对象，关于创建对象这个概念，在原型模式里面阐述过，创建对象是要深拷贝的，而不是简单的给个引用，指针之类的，这种是没有内存复制的。

下面来看看建造者模式又有什么特点？

1.原理阐述

先看官话：

建造者模式(Builder)：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

说下个人理解：
先看前半句，将一个复杂对象的构建与它的表示分离。那么这里分离的意思其实就是依赖倒置的一种体现。我们在设计模式里面做分离一般都是用接口，这里前半句就提示我们在具体实现的时候要做隔离。

后半句，同样的构建过程…，什么叫同样的构建过程，就是可以认为对象的构建，流程是一致的。比如麦当劳做汉堡，多少度烤多久，制作步骤是什么，这就是流程。

再往后看，同样的构建过程可以创建不同的表示。这里放到C++里面其实就是一种多态的表现。父类的虚函数，子类继承后要重写这个虚函数。

现在做一个总结：建造者模式就是，用依赖倒置的原则，将具有相同流程的对象构建过程放到一个接口类中，具体的实现由具体的子类做，来实现不同的效果。

2.举例

小时候喜欢玩游戏，尤其是小游戏。$4399,7K7K$都是我小时候沉醉的网站。

以前经常玩火柴人系列游戏，火柴人很好画，自己有时候下课发呆也会随便画画，画个火柴人嘛，一个头就是一个圈，四肢与身体，就是一根线嘛，简简单单右手就行。

任何火柴人的原型都是这么画的，都是有固定的头，躯干，四肢，那么这个在建造者模式中就可以认为是同样的构建过程，我们需要用一个接口来封装好，代码如下：

class PersonBuilder
{
public:
virtual void BuildHead()=0;
virtual void BuildBody()=0;
virtual void BuildLeftArm()=0;
virtual void BuildRightArm()=0;
virtual void BuildLeftLeg()=0;
virtual void BuildRightLeg()=0;
};

原理阐述中提到：将一个复杂对象的构建与它的表示分离，那么这个$PersonBuilder$类只是一个构建抽象接口类，具体的表示其实还需要一个新的类。同时，不同的火柴人，脑袋大小，身体结构等都不一样，所以还需要一个具体类去实现这个抽象接口类。
代码如下：

class PersonDisplay
{
public:
PersonDisplay(PersonBuilder *pb)
{
m_pb=pb;
}
void CreatePerson()
{
m_pb->BuildHead();
m_pb->BuildBody();
m_pb->BuildLeftArm();
m_pb->BuildRightArm();
m_pb->BuildLeftLeg();
m_pb->BuildRightLeg();
}
private:
PersonBuilder *m_pb;
};
class PersonThin:public PersonBuilder
{
public:
void BuildHead(){std::cout<<"PersonThin buildHead"<<std::endl;};
void BuildBody(){std::cout<<"PersonThin buildBody"<<std::endl;};
void BuildLeftArm(){std::cout<<"PersonThin buildLeftArm"<<std::endl;};
void BuildRightArm(){std::cout<<"PersonThin buildRightArm"<<std::endl;};
void BuildLeftLeg(){std::cout<<"PersonThin buildLeftLeg"<<std::endl;};
void BuildRightLeg(){std::cout<<"PersonThin buildRightLeg"<<std::endl;};
};
class PersonFat:public PersonBuilder
{
public:
void BuildHead(){std::cout<<"PersonFat buildHead"<<std::endl;};
void BuildBody(){std::cout<<"PersonFat buildBody"<<std::endl;};
void BuildLeftArm(){std::cout<<"PersonFat buildLeftArm"<<std::endl;};
void BuildRightArm(){std::cout<<"PersonFat buildRightArm"<<std::endl;};
void BuildLeftLeg(){std::cout<<"PersonFat buildLeftLeg"<<std::endl;};
void BuildRightLeg(){std::cout<<"PersonFat buildRightLeg"<<std::endl;};
};

int main()
{
PersonThin *a=new PersonThin();
PersonFat *b=new PersonFat();
PersonDisplay* m_pda=new PersonDisplay(a);
PersonDisplay* m_pdb=new PersonDisplay(b);
//也可以写成这样：
//PersonDisplay* m_pda=new PersonDisplay(new PersonThin());
//PersonDisplay* m_pdb=new PersonDisplay(new PersonFat());

m_pda->CreatePerson();
m_pdb->CreatePerson();

return 0;
}

本来想写伪代码的，一写就基本上都写好了。这里我们看main函数，我们用PersonDisplay这个表示类，把具体的构造过程封装了起来，但是里面的实现实际上是由具体的PersonThin类和PersonFat类去做。

总结

建造者模式适合于那种流程相对固定，且最后的需求是创建对象的场景。当然了，它本身是一个创建者模式，不创建对象的话，那就不能称之为创建者模式了。

建造者模式两个点，流程固定，依赖倒置。

原文地址：https://blog.csdn.net/Edwinwzy/article/details/144066441

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！