行为型模式--模板方法模式（Template Method）

解释一下模板方法模式，就是指：一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用，先看个关系图：

就是在AbstractCalculator类中定义一个主方法calculate，calculate()调用spilt()等，Plus和Minus分别继承AbstractCalculator类，通过对AbstractCalculator的调用实现对子类的调用，看下面的例子：

[java]  view plain copy

1. public abstract class AbstractCalculator {  
2.       
3.     /*主方法，实现对本类其它方法的调用*/  
4.     public final int calculate(String exp,String opt){  
5.         int array[] = split(exp,opt);  
6.         return calculate(array[0],array[1]);  
7.     }  
8.       
9.     /*被子类重写的方法*/  
10.     abstract public int calculate(int num1,int num2);  
11.       
12.     public int[] split(String exp,String opt){  
13.         String array[] = exp.split(opt);  
14.         int arrayInt[] = new int[2];  
15.         arrayInt[0] = Integer.parseInt(array[0]);  
16.         arrayInt[1] = Integer.parseInt(array[1]);  
17.         return arrayInt;  
18.     }  
19. }  

[java]  view plain copy

1. public class Plus extends AbstractCalculator {  
2.   
3.     @Override  
4.     public int calculate(int num1,int num2) {  
5.         return num1 + num2;  
6.     }  
7. }  

测试类：

[java]  view plain copy

1. public class StrategyTest {  
2.   
3.     public static void main(String[] args) {  
4.         String exp = "8+8";  
5.         AbstractCalculator cal = new Plus();  
6.         int result = cal.calculate(exp, "\\+");  
7.         System.out.println(result);  
8.     }  
9. }  

我跟踪下这个小程序的执行过程：首先将exp和"\\+"做参数，调用AbstractCalculator类里的calculate(String,String)方法，在calculate(String,String)里调用同类的split()，之后再调用calculate(int ,int)方法，从这个方法进入到子类中，执行完return num1 + num2后，将值返回到AbstractCalculator类，赋给result，打印出来。正好验证了我们开头的思路。

======================================================
2、下面我们用例子说明模板方法

1.模板类，相当于我们上面提到的薄片塑料板

 

[java]  view plain copy

 

1. Java代码    
2. package com.pattern.templateMethod;    
3.     
4. /**  
5.  * 抽象类,充当模板角色  
6.  * @author administrator  
7.  *  
8.  */    
9. public abstract class AbstractDisplay {    
10.     //由子类实现的抽象方法    
11.     public abstract void open();       
12.     public abstract void print();    
13.     public abstract void close();    
14.     //抽象类实现的方法,final可以保证在子类不会被修改    
15.     public final void display() {    
16.         open();   //先open...    
17.         for(int i=0; i < 5; i++) {  //反复输出5次    
18.             print();      
19.         }    
20.         close(); //输出完毕,close    
21.     }    
22. }    
23.    
24.   2.字符类，输出单个字符  
25. Java代码    
26. package com.pattern.templateMethod;    
27.     
28. public class CharDisplay extends AbstractDisplay {    
29.     private char ch;     //应输出的字符    
30.     public CharDisplay(char ch) {  //把构造函数传递过来的字符ch,存储在字段内    
31.         this.ch = ch;    
32.     }    
33.       
34.     public void open() {    
35.         System.out.print("<<");   //输出"<<"作为开始字符串    
36.     }    
37.     public void close() {    
38.         System.out.println(">>");  //输出 ">>"作为结束字符串    
39.     }    
40.     public void print() {    
41.         System.out.print(ch);    //输出存储在字段的字符    
42.     }    
43.     
44. }    
45.    
46.    3.字符串类，输出字符串  
47. Java代码    
48. package com.pattern.templateMethod;    
49.     
50. /**  
51.  *   
52.  * @author administrator  
53.  */    
54. public class StringDisplay extends AbstractDisplay {    
55.     private String string;  //应输出的字符串    
56.     private int width;      //以byte为单位所求出的字符串的"长度"    
57.         
58.     public StringDisplay(String string) {    
59.         this.string =string;    
60.         width = string.getBytes().length;    
61.     }    
62.     
63.     public void open() {  //打印头装饰字符串    
64.         printLine();    
65.     }    
66.     public void print() { //打印内容    
67.         System.out.println("|"+string+"|");    
68.     }    
69.     public void close() { //打印尾装饰字符串    
70.         printLine();    
71.     }    
72.     
73.     public void printLine() {    
74.         System.out.print("+");  //输出"+"号表示边框位置    
75.         for(int i=0; i < width; ++i) {    
76.             System.out.print("-");  //当作线段    
77.         }    
78.         System.out.println("+");  //输出"+"号表示边框位置    
79.     }    
80. }    
81.   4.测试类  
82. Java代码    
83. package com.pattern.templateMethod;    
84.     
85. public class Main {    
86.     public static void main(String[] args) {    
87.         //建立1个有'A'的CharDisplay的对象    
88.         AbstractDisplay d1 = new CharDisplay('A');    
89.         //建立1个有"Hello world"的StringDisplay的对象    
90.         AbstractDisplay d2 = new StringDisplay("Hello World");    
91.             
92.         //d1,d2都是AbstractDisplay的子类对象,可以调用继承到的display()方法    
93.         d1.display();    
94.         d2.display();    
95.     }    
96. }    
97.    
98.  输出:  
99.    
100. C代码    
101.  <<AAAAA>>    
102. +-----------+    
103. |Hello World|    
104. |Hello World|    
105. |Hello World|    
106. |Hello World|    
107. |Hello World|    
108. +-----------+    

 设计思想：作为模板的方法定义在父类（父类为抽象类），而方法定义使用抽象方法，实现抽象方法的是子类，要在子类实现方法，才能决定具体的操作。如果在不同的子类执行不同实现就可以发展出不同的处理内容。不过，无论在哪个子类执行任何一种实现，处理的大致流程都还是要依照父类制定的方式。