设计模式之模板方法模式

1、定义了一个操作中的算法的骨架，而将一些步骤延迟到了子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

当我们要完成在某一细节层次一致的一个过程或一系列步骤，但某个别步骤在更详细的层次上的实现可能不同时，我们通常考虑用模板方法来处理。

UML图如下：

2、 AbstractClass是抽象类，其实也就是一抽象模板，定义并实现了一个模板方法。这个模板方法一般是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现。顶级逻辑也有可能调用一些具体方法。

ConcreteClass，实现父类所定义的一个或多个抽象方法。每一个AbstractClass都可以有任意多个ConcreteClass与之对应，而每一个ConcreteClass都可以给出这些抽象方法(也就是顶级逻辑的组成步骤)的不同实现，从而使得顶级逻辑的实现各不相同。

3、模板方法模式特点

模板方法模式是通过把不变行为搬移到超类，去除了子类中的重复代码来体现它的优势。提供了一个很好的代码复用平台。因为有时候，我们会遇到由一系列步骤构成的过程需要执行。这个过程从高层次上看是相同的，但是有些步骤的实现可能不同。这时候，我们通常就应该要考虑用模板方法模式了。

“当不变的和变化的行为在方法的子类实现中混合在一起的时候，不变的行为就会在子类中重复出现。我们通过模板方法模式把这些行为搬移到单一的地方，这样就帮助子类摆脱重复不变行为的纠缠”。

4、C++代码实现

[cpp] view plaincopy

1. #include <iostream>  
2. using namespace std;  
3.   
4. //抽象接口类定义了算法的执行步骤框架  
5. class AbstractClass  
6. {  
7. public:  
8.     virtual void Operation1() = 0;  
9.     virtual void Operation2() = 0;  
10.     void TemplateMethod() {  
11.         Operation1();  
12.         Operation2();  
13.     }  
14. };  
15.   
16. //具体类A，实现算法的步骤的特定操作  
17. class ConcreteClassA : public AbstractClass  
18. {  
19. public:   
20.     void Operation1() {  
21.         cout << "具体类A方法1实现" << endl;  
22.     }  
23.     void Operation2() {  
24.         cout << "具体类A方法2实现" << endl;  
25.     }  
26. };  
27.   
28. //具体类B，实现算法的步骤的特定操作  
29. class ConcreteClassB : public AbstractClass   
30. {  
31. public:  
32.     void Operation1() {  
33.         cout << "具体类B方法1实现" << endl;  
34.     }  
35.     void Operation2() {  
36.         cout << "具体类B方法2实现" << endl;  
37.     }  
38. };  
39.   
40. int main()  
41. {  
42.     AbstractClass * p_abstractClass = new ConcreteClassA();  
43.     p_abstractClass->TemplateMethod();  
44.     delete p_abstractClass;  
45.     p_abstractClass = new ConcreteClassB();  
46.     cout << endl;  
47.     p_abstractClass->TemplateMethod();  
48.     delete p_abstractClass;  
49.     p_abstractClass = NULL;  
50.     return 0;  
51. }  

在举一个实际的例子

   最近有个招聘会，可以带上简历去应聘了。但是，其中有一家公司不接受简历，而是给应聘者发了一张简历表，上面有基本信息、教育背景、工作经历等栏，让应聘者按照要求填写完整。每个人拿到这份表格后，就开始填写。如果用程序实现这个过程，该如何做呢？一种方案就是用模板方法模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。我们的例子中，操作就是填写简历这一过程，我们可以在父类中定义操作的算法骨架，而具体的实现由子类完成。下面给出它的UML图。

  其中FillResume() 定义了操作的骨架，依次调用子类实现的函数。相当于每个人填写简历的实际过程。接着给出相应的C++代码。

[cpp]  view plain copy print ?

1. //简历  
2. class Resume  
3. {  
4. protected: //保护成员  
5.     virtual void SetPersonalInfo() {}  
6.     virtual void SetEducation() {}  
7.     virtual void SetWorkExp() {}  
8. public:  
9.     void FillResume()   
10.     {  
11.         SetPersonalInfo();  
12.         SetEducation();  
13.         SetWorkExp();  
14.     }  
15. };  
16. class ResumeA: public Resume  
17. {  
18. protected:  
19.     void SetPersonalInfo() { cout<<"A's PersonalInfo"<<endl; }  
20.     void SetEducation() { cout<<"A's Education"<<endl; }  
21.     void SetWorkExp() { cout<<"A's Work Experience"<<endl; }  
22. };  
23. class ResumeB: public Resume  
24. {  
25. protected:  
26.     void SetPersonalInfo() { cout<<"B's PersonalInfo"<<endl; }  
27.     void SetEducation() { cout<<"B's Education"<<endl; }  
28.     void SetWorkExp() { cout<<"B's Work Experience"<<endl; }  
29. };  

        使用方式如下：

[cpp]  view plain copy print ?

1. int main()  
2. {  
3.     Resume *r1;  
4.     r1 = new ResumeA();  
5.     r1->FillResume();  
6.     delete r1;  
7.     r1 = new ResumeB();  
8.     r1->FillResume();  
9.     delete r1;  
10.     r1 = NULL;  
11.     return 0;  
12. }