模板方法模式

Template Method（模板方法）

1、意图：

定义一个操作中的算法骨架，而将一些步骤的具体实现延迟到子类中。TemplateMethod 使得子类可以不改变一个算法的结构（步骤）即可重定义该算法的某些特定步骤的具体实现。

2、模式中的角色

　　抽象类（AbstractClass）：实现了模板方法，定义了算法的骨架。

　　具体类（ConcreteClass)：实现抽象类中的抽象方法，已完成完整的算法。

3、模板方法类图

4、实例：

去饭馆吃饭，一般分可分为3个步骤，点菜、吃饭、买单，而每个人去吃都是这个步骤，不同得是点的菜、吃饭花的时间、花的钱不一样而已，所以可以将点菜、吃饭、买单这3个步骤分别写成3个方法，而把这3个方法放到一个模板方法里面。具体实现如下：

   AbstractClass：

Java代码  

1. /** 
2.  * 餐馆吃饭抽象类 
3.  *  
4.  * @author xieke 
5.  * @since 15.7.28 
6.  */  
7. public abstract class Eat  
8. {  
9.   
10.     // 所点菜的集合  
11.     protected List<Menu> list;  
12.   
13.     /** 
14.      * 吃饭模板方法 
15.      * @param list 
16.      * @return 
17.      */  
18.     public double eat(List<Menu> list)  
19.     {  
20.         // 1.点菜  
21.         this.dianCai(list);  
22.         // 2.吃饭  
23.         this.chiFan();  
24.         // 3.买单  
25.         return this.maiDan();  
26.     }  
27.   
28.     /** 
29.      * 点菜 
30.      * @param list 
31.      */  
32.     public void dianCai(List<Menu> list)  
33.     {  
34.         this.list = list;  
35.     }  
36.   
37.     /** 
38.      * 吃饭 
39.      */  
40.     public abstract void chiFan();  
41.   
42.     /** 
43.      * 买单 
44.      * @return 
45.      */  
46.     public double maiDan()  
47.     {  
48.         double money = 0.0;  
49.         for (Menu menu : list)  
50.         {  
51.             money += menu.getMoney();  
52.         }  
53.         return money;  
54.     }  
55. }  

    ConcreteClass：

Java代码  

1. public class MeEat extends Eat  
2. {  
3.   
4.     @Override  
5.     public void chiFan()  
6.     {  
7.         System.out.println("我吃饭花了30分钟......");  
8.           
9.         for(Menu menu : this.list){  
10.             System.out.println(menu.toString());  
11.         }  
12.   
13.     }  
14.   
15. }  

    菜单实体类：

Java代码  

1. public class Menu  
2. {  
3.     private String name;  
4.     private double money;  
5.     public String getName()  
6.     {  
7.         return name;  
8.     }  
9.     public void setName(String name)  
10.     {  
11.         this.name = name;  
12.     }  
13.     public double getMoney()  
14.     {  
15.         return money;  
16.     }  
17.     public void setMoney(double money)  
18.     {  
19.         this.money = money;  
20.     }  
21.     public Menu(String name, double money)  
22.     {  
23.         this.name = name;  
24.         this.money = money;  
25.     }  
26.     @Override  
27.     public String toString()  
28.     {  
29.         return  name + "：" + money;  
30.     }  
31. }  

    测试类：

Java代码  

1. public class MainClass  
2. {  
3.     public static void main(String[] args)  
4.     {  
5.         Eat eat = new MeEat();  
6.         List<Menu> list = new ArrayList<Menu>();  
7.         list.add(new Menu("水煮牛肉", 30.0));  
8.         list.add(new Menu("麻婆豆腐", 10.0));  
9.         System.out.println("本次吃饭共花费："+eat.eat(list));  
10.     }  
11. }  

5、模式总结

　　5.1 优点

　　　　5.1.1 模板方法模式通过把不变的行为搬移到超类，去除了子类中的重复代码。

　　　　5.1.2 子类实现算法的某些细节，有助于算法的扩展。

　　　　5.1.3 通过一个父类调用子类实现的操作，通过子类扩展增加新的行为，符合“开放-封闭原则”。

　　5.2 缺点

　　　　5.2.1 每个不同的实现都需要定义一个子类，这会导致类的个数的增加，设计更加抽象。

　　5.3 适用场景

　　　　5.1 在某些类的算法中，用了相同的方法，造成代码的重复。

　　　　5.2 控制子类扩展，子类必须遵守算法规则。

 

   

   转载请注明出处：http://xieke90.iteye.com/blog/2230939