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

发布于:2024-11-29 ⋅ 阅读:(28) ⋅ 点赞:(0)

前言

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

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

1.原理阐述

先看官话:

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

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

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

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

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

2.举例

小时候喜欢玩游戏,尤其是小游戏。 4399 , 7 K 7 K 4399,7K7K 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;
};

原理阐述中提到:将一个复杂对象的构建与它的表示分离,那么这个 P e r s o n B u i l d e r PersonBuilder 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类去做。

总结

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

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