转载请注明出处:http://blog.csdn.net/lmj623565791/article/details/26276093

不断设计模式~ Template Method模式

老套路,看高清:它定义的算法的骨架。虽然某些步骤推迟到子类中。不改变算法结构的情况下。又一次定义算法的步骤。

简单看下定义,模版方法定义了一个算法的步骤,而且同意子类为一个或多个步骤提供实现。

定义还算清晰,以下来个样例展示下本公司的上班情况(纯属娱乐,如有雷同。请对号入座)。简单描写叙述一下:本公司有程序员、測试、HR、项目经理等人,以下使用模版方法模式,记录下全部人员的上班情况:

首先来个超类,超类中定义了一个workOneDay方法。设置为作为算法的骨架:

  1. package com.zhy.pattern.template;
  2.  
  3. public abstract class Worker
  4. {
  5. protected String name;
  6.  
  7. public Worker(String name)
  8. {
  9. this.name = name;
  10. }
  11.  
  12. /**
  13. * 记录一天的工作
  14. */
  15. public final void workOneDay()
  16. {
  17.  
  18. System.out.println("-----------------work start ---------------");
  19. enterCompany();
  20. computerOn();
  21. work();
  22. computerOff();
  23. exitCompany();
  24. System.out.println("-----------------work end ---------------");
  25.  
  26. }
  27.  
  28. /**
  29. * 工作
  30. */
  31. public abstract void work();
  32.  
  33. /**
  34. * 关闭电脑
  35. */
  36. private void computerOff()
  37. {
  38. System.out.println(name + "关闭电脑");
  39. }
  40.  
  41. /**
  42. * 打开电脑
  43. */
  44. private void computerOn()
  45. {
  46. System.out.println(name + "打开电脑");
  47. }
  48.  
  49. /**
  50. * 进入公司
  51. */
  52. public void enterCompany()
  53. {
  54. System.out.println(name + "进入公司");
  55. }
  56.  
  57. /**
  58. * 离开公司
  59. */
  60. public void exitCompany()
  61. {
  62. System.out.println(name + "离开公司");
  63. }
  64.  
  65. }

定义了一个上班(算法)的骨架,包括下面步骤:

a、进入公司

b、打开电脑

c、上班情况

d、关闭电脑

e、离开公司

能够看到,a、b、d、e我们在超类中已经实现,子类仅实现work这个抽象方法,记录每天的上班情况。以下各类屌丝入场:

程序员:

  1. package com.zhy.pattern.template;
  2.  
  3. public class ITWorker extends Worker
  4. {
  5.  
  6. public ITWorker(String name)
  7. {
  8. super(name);
  9. }
  10.  
  11. @Override
  12. public void work()
  13. {
  14. System.out.println(name + "敲代码-測bug-fix bug");
  15. }
  16.  
  17. }

HR:

  1. package com.zhy.pattern.template;
  2.  
  3. public class HRWorker extends Worker
  4. {
  5.  
  6. public HRWorker(String name)
  7. {
  8. super(name);
  9. }
  10.  
  11. @Override
  12. public void work()
  13. {
  14. System.out.println(name + "看简历-打电话-接电话");
  15. }
  16.  
  17. }

測试人员:

  1. package com.zhy.pattern.template;
  2.  
  3. public class QAWorker extends Worker
  4. {
  5.  
  6. public QAWorker(String name)
  7. {
  8. super(name);
  9. }
  10.  
  11. @Override
  12. public void work()
  13. {
  14. System.out.println(name + "写測试用例-提交bug-写測试用例");
  15. }
  16.  
  17. }

项目经理:

  1. package com.zhy.pattern.template;
  2.  
  3. public class ManagerWorker extends Worker
  4. {
  5.  
  6. public ManagerWorker(String name)
  7. {
  8. super(name);
  9. }
  10.  
  11. @Override
  12. public void work()
  13. {
  14. System.out.println(name + "打dota...");
  15. }
  16.  
  17. }

以下我们測试下:

  1. package com.zhy.pattern.template;
  2.  
  3. public class Test
  4. {
  5. public static void main(String[] args)
  6. {
  7.  
  8. Worker it1 = new ITWorker("鸿洋");
  9. it1.workOneDay();
  10. Worker it2 = new ITWorker("老张");
  11. it2.workOneDay();
  12. Worker hr = new HRWorker("迪迪");
  13. hr.workOneDay();
  14. Worker qa = new QAWorker("老李");
  15. qa.workOneDay();
  16. Worker pm = new ManagerWorker("坑货");
  17. pm.workOneDay();
  18.  
  19. }
  20. }

输出结果:

  1. -----------------work start ---------------
  2. 鸿洋进入公司
  3. 鸿洋打开电脑
  4. 鸿洋敲代码-測bug-fix bug
  5. 鸿洋关闭电脑
  6. 鸿洋离开公司
  7. -----------------work end ---------------
  8. -----------------work start ---------------
  9. 迪迪进入公司
  10. 迪迪打开电脑
  11. 迪迪看简历-打电话-接电话
  12. 迪迪关闭电脑
  13. 迪迪离开公司
  14. -----------------work end ---------------
  15. -----------------work start ---------------
  16. 老李进入公司
  17. 老李打开电脑
  18. 老李写測试用例-提交bug-写測试用例
  19. 老李关闭电脑
  20. 老李离开公司
  21. -----------------work end ---------------
  22. -----------------work start ---------------
  23. 坑货进入公司
  24. 坑货打开电脑
  25. 坑货打dota...
  26. 坑货关闭电脑
  27. 坑货离开公司
  28. -----------------work end ---------------

好了,恭喜你,又学会一个设计模式。模版方法模式。

以下看下模版方法模式类图,和我们程序的类图:

模版方式里面也能够可选的设置钩子,比方如今希望记录程序猿离开公司的时间。我们就能够在超类中加入一个钩子:

  1. public boolean isNeedPrintDate()
  2. {
  3. return false;
  4. }
  5. /**
  6. * 离开公司
  7. */
  8. public void exitCompany()
  9. {
  10. if (isNeedPrintDate())
  11. {
  12. System.out.print(new Date().toLocaleString()+"-->");
  13. }
  14. System.out.println(name + "离开公司");
  15. }

超类中加入了一个isNeedPrintDate方法。且默认返回false,不打印时间。假设某子类须要调用打印时间。能够复写改钩子方法,返回true,比方,程序员复写了这种方法:

  1. package com.zhy.pattern.template;
  2.  
  3. public class ITWorker extends Worker
  4. {
  5.  
  6. public ITWorker(String name)
  7. {
  8. super(name);
  9. }
  10.  
  11. @Override
  12. public void work()
  13. {
  14. System.out.println(name + "敲代码-測bug-fix bug");
  15. }
  16.  
  17. @Override
  18. public boolean isNeedPrintDate()
  19. {
  20. return true;
  21. }
  22.  
  23. }

最后再看下測试结果:

  1. -----------------work start ---------------
  2. 鸿洋进入公司
  3. 鸿洋打开电脑
  4. 鸿洋敲代码-測bug-fix bug
  5. 鸿洋关闭电脑
  6. 2014-5-19 19:17:05-->鸿洋离开公司
  7. -----------------work end ---------------

好了。关于钩子,超类中可提供默认实现或者空实现,子类可覆盖或者不覆盖。详细依据需求来定。

近期恰好,再写一个爬虫程序。用到了模版方法模式,给大家分享下:

需求分析:程序须要对特定的20个站点进行抓取数据;每一个站点页面返回的结果数据不同,url不同,參数不同等;可是抓取的过程是一致的。

于是我就这种设计:

a、定义一个规则Rule类(包括了:url。params。request_method,以及返回哪块数据【依据选择器】)

b、通过Rule进行抓取数据

c、对数据进行处理

我把上面3个步骤定义了算法的骨架,b为超类实现。a、c由子类实现:

  1. package com.zhy.pattern.template;
  2.  
  3. public abstract class AbsExtractInfo
  4. {
  5.  
  6. /**
  7. * 抓取的算法骨架
  8. */
  9. public void extract()
  10. {
  11. Rule rule = generateRule() ;
  12. List<Element> eles = getInfosByRule(rule);
  13. dealResult(eles);
  14. }
  15.  
  16. /**
  17. * 生成一个Rule
  18. * @return
  19. */
  20. public abstract Rule generateRule();
  21.  
  22. /**
  23. * 抓取的实现
  24. * @param rule
  25. * @return
  26. */
  27. private List<Element> getInfosByRule(Rule rule)
  28. {
  29. // the implements omitted
  30. }
  31. /**
  32. * 处理抓取的结果
  33. * @param results
  34. */
  35. public void dealResult(List<Element> results);
  36. }

当中GenerateRule这种方法,恰好是工厂模式中的抽象方法模式(定义一个创建对象的接口。但由子类决定要实例化的类是哪一个。工厂方法模式把类实例化的过程推迟到子类),假设你忘记了,能够查看设计模式
工厂模式 从卖肉夹馍说起

好了,就到这里,最后欢迎大家留言。

版权声明:本文博主原创文章。博客,未经同意不得转载。

设计模式 Template Method模式 显示程序猿的一天的更多相关文章

  1. 设计模式Template Method模式(Template Method)摘录

    23种子GOF设计模式一般分为三类:创建模式.结构模型.行为模式. 创建模式抽象的实例.怎样创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化托付给还 ...

  2. Android 设计模式Template Method模式

    自定义模板方法模式:定义的算法的骨架中的方法,虽然某些步骤推迟到子类中,下模板方法允许子类不能改变在的情况下,该算法的结构.算法重新定义某些步骤. 设计原则:不要给我们打电话.我会打电话给你.(像猎头 ...

  3. 一天一个设计模式——模板方法(Template Method)模式

    一.模式说明 现实世界中的模板是用于将事物的结构规律予以固定化.标准化的成果,它体现了结构形式的标准化.例如镂空文字印刷的模板,通过某个模板印刷出来的文字字体大小都是一模一样,但是具体使用什么材质的颜 ...

  4. 设计模式(三)Template Method模式

    在父类中定义处理流程的框架,在子类中实现具体处理的模式就称为Template Method模式即模板方法模式. 根据下面的示例程序理解模板方法模式. package BigJunOba.bjtu.Te ...

  5. 设计模式之Template Method模式

    作用:将具体的处理交给子类 什么是Template Method模式? Template Method模式是指带有模板功能的模式,组成模板的方法被定义在父类中,且这些方法为抽象方法.子类去实现父类中的 ...

  6. 行为型设计模式之模板方法(TEMPLATE METHOD)模式 ,策略(Strategy )模式

    1 模板方法(TEMPLATE METHOD)模式: 模板方法模式把我们不知道具体实现的步聚封装成抽象方法,提供一些按正确顺序调用它们的具体方法(这些具体方法统称为模板方法),这样构成一个抽象基类.子 ...

  7. C++设计模式:Template Method

    我使用过一个简单的后台服务框架.这个框架上手很容易,我只需要继承一个基类,同时实现,或重写(override)基类声明的几个接口(这些接口声明为虚函数,或者纯虚函数),然后调用基类定义好的run()函 ...

  8. Template Method模式和Strategy模式有何异同

    Template Method模式和Strategy模式有何异同 博客分类: 设计模式 Java  Template Method模式很容易理解,就是由基类提供一个模板,将各子类中不变的行为提取到基类 ...

  9. Template Method模式和Strategy模式[继承与委托]

    继承 program by difference. 通过继承,可以建立完整的软件结构分层.其中每一层都可以重用该层次以上的Code. 过度使用继承的代价是巨大的.应使用组合或者委托来替代继承. Tem ...

随机推荐

  1. 十分钟搞懂什么是CGI(转)

    原文:CGI Made Really Easy,在翻译的过程中,我增加了一些我在学习过程中找到的更合适的资料,和自己的一些理解.不能算是严格的翻译文章,应该算是我的看这篇文章的过程的随笔吧. CGI真 ...

  2. Oracle练习

    --声明一个变量,并给它赋值 declare  v_bonus number(8); begin select id*6 into v_bonus from A where Id=5; DBMS_OU ...

  3. 设计模式之迭代器模式(Iterator)摘录

    23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于怎样创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而 ...

  4. hdu1664 Different Digits

    求出n的倍数m,要求m使用的不同数字最少,且最小. 一开始不知道怎么搜,因为不知道m由多少个不同的数字组成. 然后百度了一下,看到和数论有关. m可能使用的数字的个数可能为一个或者两个 a,aa,aa ...

  5. CSS检测的高像素密度屏幕设备

    iPhone4尽管是640px解析度,但它的屏幕宽度(device-width)目前只有320px和iPhone3G相同.只是iPhone4S的像素密度2. 然后使用meta viewport什么时候 ...

  6. C语言static 具体分析

    google在最后三页C语言static内容,可找到的资料非常少.无论是长篇大论不知所云的话,在关键位置或跳过,习的人来说參考性不是非常大.所以.我这篇博文博採众家之长,把互联网上的资料整合归类,并亲 ...

  7. 苹果公司的新的编程语言 Swift 高级语言(十一)--初始化类的析构函数的一个实例

    一 .实例的初始化          实例的初始化是准备一个类.结构或枚举的实例以便使用的过程. 初始化包含设置一个实例的每个存储属性为一个初始值,以及运行不论什么其他新的实例可以使用之前须要的设置或 ...

  8. Keepalived 配置和使用

    keepalived主要用作RealServer的健康状态检查以及LoadBalance主机和BackUP主机之间failover的实现.keepalived主要目的在于,其自身启动一个服务,能够实现 ...

  9. 【剑指offer】q50:树节点最近的祖先

    #@ root: the root of searched tree #@ nodeToFind: the tree-node to be found #@ path: the path from r ...

  10. Sliverlight实例之 使用 ControlTemplate 自定义按钮的外观

    按钮,最终效果,如下图: 见Project21_ButtonSkin 1, 创建Sliverlight项目 说明: generic.xaml:样式和模板就被定义在这个文件里 MyButton.cs:控 ...