模板方法模式

转载 2017年01月03日 22:14:51

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

举报

相关文章推荐

返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)