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

  程序示例类之间的关系

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

Java代码

1. package com.pattern.templateMethod;   
2.   
3. /**  
4.  * 抽象类,充当模板角色  
5.  * @author administrator  
6.  *  
7.  */  
8. public abstract class AbstractDisplay {   
9.     //由子类实现的抽象方法   
10.     public abstract void open();      
11.     public abstract void print();   
12.     public abstract void close();   
13.     //抽象类实现的方法,final可以保证在子类不会被修改   
14.     public final void display() {   
15.         open();   //先open...   
16.         for(int i=0; i < 5; i++) {  //反复输出5次   
17.             print();     
18.         }   
19.         close(); //输出完毕,close   
20.     }   
21. }  

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代码

1. package com.pattern.templateMethod;   
2.   
3. public class CharDisplay extends AbstractDisplay {   
4.     private char ch;     //应输出的字符   
5.     public CharDisplay(char ch) {  //把构造函数传递过来的字符ch,存储在字段内   
6.         this.ch = ch;   
7.     }   
8.      
9.     public void open() {   
10.         System.out.print("<<");   //输出"<<"作为开始字符串   
11.     }   
12.     public void close() {   
13.         System.out.println(">>");  //输出 ">>"作为结束字符串   
14.     }   
15.     public void print() {   
16.         System.out.print(ch);    //输出存储在字段的字符   
17.     }   
18.   
19. }  

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代码

1. package com.pattern.templateMethod;   
2.   
3. /**  
4.  *   
5.  * @author administrator  
6.  */  
7. public class StringDisplay extends AbstractDisplay {   
8.     private String string;  //应输出的字符串   
9.     private int width;      //以byte为单位所求出的字符串的"长度"   
10.        
11.     public StringDisplay(String string) {   
12.         this.string =string;   
13.         width = string.getBytes().length;   
14.     }   
15.   
16.     public void open() {  //打印头装饰字符串   
17.         printLine();   
18.     }   
19.     public void print() { //打印内容   
20.         System.out.println("|"+string+"|");   
21.     }   
22.     public void close() { //打印尾装饰字符串   
23.         printLine();   
24.     }   
25.   
26.     public void printLine() {   
27.         System.out.print("+");  //输出"+"号表示边框位置   
28.         for(int i=0; i < width; ++i) {   
29.             System.out.print("-");  //当作线段   
30.         }   
31.         System.out.println("+");  //输出"+"号表示边框位置   
32.     }   
33. }  

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代码

1. package com.pattern.templateMethod;   
2.   
3. public class Main {   
4.     public static void main(String[] args) {   
5.         //建立1个有'A'的CharDisplay的对象   
6.         AbstractDisplay d1 = new CharDisplay('A');   
7.         //建立1个有"Hello world"的StringDisplay的对象   
8.         AbstractDisplay d2 = new StringDisplay("Hello World");   
9.            
10.         //d1,d2都是AbstractDisplay的子类对象,可以调用继承到的display()方法   
11.         d1.display();   
12.         d2.display();   
13.     }   
14. }  

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代码

1.  <<AAAAA>>   
2. +-----------+   
3. |Hello World|   
4. |Hello World|   
5. |Hello World|   
6. |Hello World|   
7. |Hello World|   
8. +-----------+  

 <<AAAAA>>
+-----------+
|Hello World|
|Hello World|
|Hello World|
|Hello World|
|Hello World|
+-----------+

设计思想：

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