行为型模式--模板方法模式(Template Method)

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

行为型模式--模板方法模式(Template Method)

就是在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. +-----------+    
 设计思想:作为模板的方法定义在父类(父类为抽象类),而方法定义使用抽象方法,实现抽象方法的是子类,要在子类实现方法,才能决定具体的操作。如果在不同的子类执行不同实现就可以发展出不同的处理内容。不过,无论在哪个子类执行任何一种实现,处理的大致流程都还是要依照父类制定的方式。

 

你可能感兴趣的:(java,设计模式)