设计模式学习笔记——模板方法模式

原文：http://blog.youkuaiyun.com/hackerain/article/details/7536483

定义：

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

模板方法模式类中，有两种方法，一种是基本方法，是由子类实现的，并且在模板方法中调用，这些函数要定义成抽象的；第二种方法时模板方法，实现对基本方法的调度，完成固定的逻辑，这个方法是在父类中就已经实现了的。我们还可以在父类中，定义一个“钩子函数”，用以控制模板方法中，某些基本方法是否执行，这个“钩子函数”可以由子类覆盖，并且在子类中去改变它的返回值，从而控制父类模板方法中某些方法是否执行。具体类图如下：

代码如下：

[java]  view plain copy

1. public abstract class AbstractTemplate {  
2.       
3.     //基本方法，由子类去实现  
4.     protected abstract void doSomething1();  
5.     protected abstract void doSomething2();  
6.     protected abstract void doSomething3();  
7.       
8.     //模板方法，为了防止恶意的操作，一般模板方法上都加上final关键字，不允许被覆写  
9.     public final void templateMethod(){  
10.         doSomething1();  
11.         if(this.hook())  
12.             doSomething2();  
13.         doSomething3();  
14.     }  
15.       
16.     //hook函数，用来控制doSomething2()函数是否执行，默认的是执行的  
17.     protected boolean hook(){  
18.         return true;  
19.     }  
20. }  

[java]  view plain copy

1. /** 
2.  * doSomething2()总是不执行 
3.  */  
4. public class ConcreteTemplate1 extends AbstractTemplate {  
5.   
6.     @Override  
7.     protected void doSomething1() {  
8.         System.out.println("template1 do something 1");  
9.     }  
10.   
11.     @Override  
12.     protected void doSomething2() {  
13.         System.out.println("template1 do something 2");  
14.     }  
15.   
16.     @Override  
17.     protected void doSomething3() {  
18.         System.out.println("template1 do something 3");  
19.     }  
20.       
21.     //返回false，表示设置doSomething2()方法总是不执行  
22.     protected boolean hook(){  
23.         return false;  
24.     }  
25. }  

[java]  view plain copy

1. /** 
2.  * 可以在外部控制doSomething2()方法是否执行 
3.  */  
4. public class ConcreteTemplate2 extends AbstractTemplate {  
5.     private boolean isExecute=true;  
6.       
7.     @Override  
8.     protected void doSomething1() {  
9.         System.out.println("template2 do something 1");  
10.     }  
11.   
12.     @Override  
13.     protected void doSomething2() {  
14.         System.out.println("template2 do something 2");  
15.     }  
16.   
17.     @Override  
18.     protected void doSomething3() {  
19.         System.out.println("template2 do something 3");  
20.     }  
21.       
22.     //覆盖父类的hook()方法  
23.     protected boolean hook(){  
24.         return this.isExecute;  
25.     }  
26.       
27.     public void setHook(boolean isExecute){  
28.         this.isExecute=isExecute;  
29.     }  
30. }  

[java]  view plain copy

1. /** 
2.  * 使用默认的设置，即doSomething2()方法总是执行 
3.  */  
4. public class ConcreteTemplate3 extends AbstractTemplate {  
5.   
6.     @Override  
7.     protected void doSomething1() {  
8.         System.out.println("template3 do something 1");  
9.     }  
10.   
11.     @Override  
12.     protected void doSomething2() {  
13.         System.out.println("template3 do something 2");  
14.     }  
15.   
16.     @Override  
17.     protected void doSomething3() {  
18.         System.out.println("template3 do something 3");  
19.     }  
20.   
21. }  

场景类：

[java]  view plain copy

1. public class Client {  
2.     public static void main(String[] args) {  
3.         ConcreteTemplate1 t1=new ConcreteTemplate1();  
4.         t1.templateMethod();  
5.           
6.         ConcreteTemplate2 t2=new ConcreteTemplate2();  
7.         t2.setHook(true);//可以在这里设置doSomething2()方法是否执行  
8.         t2.templateMethod();  
9.           
10.         ConcreteTemplate3 t3=new ConcreteTemplate3();  
11.         t3.templateMethod();  
12.     }  
13. }  

模板方法模式的优点：

1、封装不变部分，扩展可变部分

2、提取公共部分的代码，便于维护

3、行为由父类控制，子类实现。基本方法是由子类实现的，因此子类可以通过扩展的方式增加相应的功能，符合开闭原则。

模板方法模式的使用场景：

1、多个子类有公有的方法，并且逻辑基本相同时

2、重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现

3、重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数约束其行为