设计模式之模板方法

设计模式之模板方法

1.意图

根据GOF中的定义：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中实现。模板方法使得子类可以不改变一个算法的结构就可重定义算法的某些特定步骤。

很明显，模板方法就是抽象出某个问题的解决算法，封装算法框架，开放一些特定步骤让子类继承抽象类后重新定义，从而实现改变这个解决算法。这在实际中是实用很广的算法。

2.动机

这样做有很大的好处，最重要的一点我认为是根据某个问题的解决算法而定制化算法的特定步骤，做到使算法或操作框架稳定，而实现步骤特定化，提高代码的复用性。

模板方法通过一些抽象的操作定义一个算法，子类重定义这些操作，模板方法确定这些操作的顺序，实现满足各自的需求。

3.模式结构与角色定义

如图，抽象类定义某些特定步骤，然后templateMethod对这些操作确定顺序（需要的话可以添加课外的逻辑代码），具体类继承抽象类，重定义这些特定的步骤。有时候，在这个结构中还有一个钩子函数，是用于控制模板方法的某些逻辑，一般是把钩子函数放在抽象类中，然后具体类通过重写钩子函数来影响模板方法的逻辑，这样做的好处是以防多个不同子类需要重新定义钩子函数。这样一个完整的模板方法就完成了。

在这个模板方法设计模式中，一共有以下的角色：

• 1.AbstractClass:

• 1.定义抽象的操作，被子类继承重写以实现一个算法的步骤。

• 2.定义好一个算法的骨架或特定步骤。

• 2.ConcreteClass:

• 1.继承抽象类，重写各个步骤，以实现完善算法的步骤

4.应用场景

1.一次性实现算法的不变部分，并将可变的行为留给子类实现。

2.各子类将公共的部分提取出来抽象父类，然后各自继承重写特定操作，提高代码的复用性

3.控制拓展子类。通过钩子函数，子类也可以控制算法的某些步骤逻辑。

5.模式的实现步骤与例子

模板的实现可以简单总结为：

1.提取出不变或者公共的架构，把变化的抽象化，抽象成抽象类或接口。

2.具体类继承抽象类或接口，重写变化的步骤

3.客户端实例化具体类，直接调用模板方法解决问题。

例子：去3天马尔代夫旅游，定好目的地，并且小情侣想每天尝试不同的交通方式，因此每天的交通工具不一样，但是目的地都是一样的。因此可以说是总体的旅游路线是一致的，但是每天的交通方法不一样，所以可以定好一个去目的地的模板，然后只改变3天的交通方式，就可以了。

//抽象类
#include <iostream>

/************************************************************************/
/* 定义旅游交通方式的接口 */
/************************************************************************/
class ITravel {
public:
	ITravel(){
		is_other = false; //默认不坐其他交通方式
	}
	virtual ~ITravel(){}

protected:	
	virtual bool Day1() = 0;
	virtual void Day2() = 0;
	virtual void Day3() = 0;

public:
	//旅游路线模板
	void Travel() {
		std::cout<<"============旅行开始==========="<<std::endl;
		if (Day1())
		{
			Day2();
		}
		if (is_other)
		{
			std::cout<<"额外方式：坐火箭"<<std::endl;
		}
		Day3();
		std::cout<<"============旅行结束==========="<<std::endl;
		std::cout<<std::endl;
	}

	//钩子函数
	virtual void SetAttrHood() = 0;
	void SetOther(bool other) {
		is_other = other;
	}

private:
	bool is_other;//是否乘坐其他
};

以上抽象类抽象出算法的框架，并且定义好步骤。

//具体类A
class TravelA : public ITravel
{
public:
	TravelA(){}
	~TravelA(){}

protected:
	bool Day1() override {
		std::cout<<"第一天：坐大巴"<<std::endl;
		return true;
	}

	void Day2() override {
		std::cout<<"第一天：坐飞机"<<std::endl;
	}

	void Day3() override {
		std::cout<<"第一天：坐轮船"<<std::endl;
	}
	
	void SetAttrHood() override {
		SetOther(true);
	}
};

具体类继承抽象类，并且重写特定的步骤，定制化算法。

//具体类B
class TravelB : public ITravel
{
public:
	TravelB(){}
	~TravelB(){}

protected:
	bool Day1() override {
		std::cout<<"步骤一：坐飞机"<<std::endl;
		return true;
	}

	void Day2() override {
		std::cout<<"步骤二：坐轮船，"<<std::endl;
	}

	void Day3() override {
		std::cout<<"步骤三：坐大巴"<<std::endl;
	}

	void SetAttrHood() override {
		SetOther(false);
	}
};

具体类继承抽象类，并且重写特定的步骤，定制化算法。

//客户端程序
#include "template_method.h"

int main()
{
	ITravel* travelA = new TravelA();
	travelA->SetAttrHood();
	travelA->Travel();

	ITravel* travelB = new TravelB();
	travelB->SetAttrHood();
	travelB->Travel();

	system("pause");

	delete travelA;
	delete travelB;
	return 0;
}

以下是打印结果：

============旅行开始===========
第一天：坐大巴
第一天：坐飞机
额外方式：坐火箭
第一天：坐轮船
============旅行结束===========

============旅行开始===========
步骤一：坐飞机
步骤二：坐轮船，
步骤三：坐大巴
============旅行结束===========

6.小结

模板方法是一个很常用的方法，能够提高代码的复用性，关键点是找出解决一个问题的变与不变的分层点，封装不变的，定义好骨架，留出变化的给子类重写实现，就可以使同一个算法框架，被实现成解决相似的问题。