设计模式(22)-行为型模式-Template Method模式

功能

                在面向对象系统的分析与设计过程中经常会遇到这样一种情况：对于某一个业务逻辑（算法实现）在不同的对象中有不同的细节实现，但是逻辑（算法）的框架（或通用的应用算法）是相同的。Template提供了这种情况的一个实现框架。

           Template模式是采用继承的方式实现这一点：将逻辑（算法）框架放在抽象基类中，并定义好细节的接口，子类中实现细节。【注释1】

                【注释1】：Strategy模式解决的是和Template模式类似的问题，但是Strategy模式是将逻辑（算法）封装到一个类中，并采取组合（委托）的方式解决这个问题。

3.10.2结构

•  A b s t r a c t C l a s s（抽象类，如A p p l i c a t i o n）

— 定义抽象的 原语操作（primitive operation） ，具体的子类将重定义它们以实现一个算法的各步骤。

— 实现一个模板方法,定义一个算法的骨架。该模板方法不仅调用原语操作，也调用定义在Ab s t r a c t C l a s s或其他对象中的操作。

•  C o n c r e t e C l a s s（具体类，如M y A p p l i c a t i on）

— 实现原语操作以完成算法中与特定子类相关的步骤。

协作：

•ConcreteClass靠Ab s t r a c t C l a s s来实现算法中不变的步骤。就是利用面向对象中多态的概念实现算法实现细节和高层接口的松耦合。

模板方法导致一种反向的控制结构(IoC)，这种结构有时被称为“好莱坞法则” ，即“别找我们，我们找你”.

3.10.3 C++代码示例

//Template.h

#ifndef _TEMPLATE_H_

#define _TEMPLATE_H_

class AbstractClass

{

public:

       virtual ~AbstractClass();

       void TemplateMethod();

protected:

       virtualvoidPrimitiveOperation1() = 0;

       virtualvoidPrimitiveOperation2() = 0;

       AbstractClass();

private:

};

 

class ConcreteClass1 :publicAbstractClass

{

public:

       ConcreteClass1();

       ~ConcreteClass1();

protected:

       void PrimitiveOperation1();

       void PrimitiveOperation2();

private:

};

 

class ConcreteClass2 :publicAbstractClass

{

public:

       ConcreteClass2();

       ~ConcreteClass2();

protected:

       void PrimitiveOperation1();

       void PrimitiveOperation2();

private:

};

#endif //~TEMPLATEH

 

//Template.cpp

#include"Template.h"

#include<iostream>

using namespace std;

AbstractClass::AbstractClass()

{

}

AbstractClass::~AbstractClass()

{

}

void AbstractClass::TemplateMethod()

{

       this->PrimitiveOperation1();

       this->PrimitiveOperation2();

}

 

ConcreteClass1::ConcreteClass1()

{

}

ConcreteClass1::~ConcreteClass1()

{

}

void ConcreteClass1::PrimitiveOperation1()

{

       cout << "ConcreteClass1...PrimitiveOperat

              ion1"<<endl;

}

void ConcreteClass1::PrimitiveOperation2()

{

       cout << "ConcreteClass1...PrimitiveOperat

              ion2"<<endl;

}

ConcreteClass2::ConcreteClass2()

{

}

ConcreteClass2::~ConcreteClass2()

{

}

void ConcreteClass2::PrimitiveOperation1()

{

       cout << "ConcreteClass2...PrimitiveOperat

              ion1"<<endl;

}

void ConcreteClass2::PrimitiveOperation2()

{

       cout << "ConcreteClass2...PrimitiveOperat

              ion2"<<endl;

}

 

//main.cpp
#include"Template.h"
#include<iostream>

using namespace std;

int main(int argc, char*argv[])

{

       AbstractClass* p1 = new ConcreteClass1();

       AbstractClass* p2 = new ConcreteClass2();

       p1->TemplateMethod();

       p2->TemplateMethod();

       return 0;

}