行为型模式--模板方法模式（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代码
package com.pattern.templateMethod;

/**
 * 抽象类,充当模板角色
 * @author administrator
 *
 */
public abstract class AbstractDisplay {
    //由子类实现的抽象方法
    public abstract void open();
    public abstract void print();
    public abstract void close();
    //抽象类实现的方法,final可以保证在子类不会被修改
    public final void display() {
        open();   //先open...
        for(int i=0; i < 5; i++) {  //反复输出5次
            print();
        }
        close(); //输出完毕,close
    }
}

  2.字符类，输出单个字符
Java代码
package com.pattern.templateMethod;

public class CharDisplay extends AbstractDisplay {
    private char ch;     //应输出的字符
    public CharDisplay(char ch) {  //把构造函数传递过来的字符ch,存储在字段内
        this.ch = ch;
    }

    public void open() {
        System.out.print("<<");   //输出"<<"作为开始字符串
    }
    public void close() {
        System.out.println(">>");  //输出 ">>"作为结束字符串
    }
    public void print() {
        System.out.print(ch);    //输出存储在字段的字符
    }

}

   3.字符串类，输出字符串
Java代码
package com.pattern.templateMethod;

/**
 *
 * @author administrator
 */
public class StringDisplay extends AbstractDisplay {
    private String string;  //应输出的字符串
    private int width;      //以byte为单位所求出的字符串的"长度"

    public StringDisplay(String string) {
        this.string =string;
        width = string.getBytes().length;
    }

    public void open() {  //打印头装饰字符串
        printLine();
    }
    public void print() { //打印内容
        System.out.println("|"+string+"|");
    }
    public void close() { //打印尾装饰字符串
        printLine();
    }

    public void printLine() {
        System.out.print("+");  //输出"+"号表示边框位置
        for(int i=0; i < width; ++i) {
            System.out.print("-");  //当作线段
        }
        System.out.println("+");  //输出"+"号表示边框位置
    }
}
  4.测试类
Java代码
package com.pattern.templateMethod;

public class Main {
    public static void main(String[] args) {
        //建立1个有'A'的CharDisplay的对象
        AbstractDisplay d1 = new CharDisplay('A');
        //建立1个有"Hello world"的StringDisplay的对象
        AbstractDisplay d2 = new StringDisplay("Hello World");

        //d1,d2都是AbstractDisplay的子类对象,可以调用继承到的display()方法
        d1.display();
        d2.display();
    }
}

 输出:

C代码
 <<AAAAA>>
+-----------+
|Hello World|
|Hello World|
|Hello World|
|Hello World|
|Hello World|
+-----------+

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