《Java设计模式》之模板方法模式

模板方法模式是类的行为模式。准备一个抽象类。将部分逻辑以详细方法以及详细构造函数的形式实现,然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类能够以不同的方式实现这些抽象方法,从而对剩余的逻辑有不同的实现。这就是模板方法模式的用意。


模板方法模式的结构

  模板方法模式是全部模式中最为常见的几个模式之中的一个。是基于继承的代码复用的基本技术。

  模板方法模式须要开发抽象类和详细子类的设计师之间的协作。一个设计师负责给出一个算法的轮廓和骨架,还有一些设计师则负责给出这个算法的各个逻辑步骤。代表这些详细逻辑步骤的方法称做基本方法(primitive method)。而将这些基本方法汇总起来的方法叫做模板方法(template method),这个设计模式的名字就是从此而来。

  模板方法所代表的行为称为顶级行为,其逻辑称为顶级逻辑。模板方法模式的静态结构图例如以下所看到的:

  这里涉及到两个角色:

  抽象模板(Abstract Template)角色有例如以下责任:

  ■  定义了一个或多个抽象操作。以便让子类实现。

这些抽象操作叫做基本操作,它们是一个顶级逻辑的组成步骤。

  ■  定义并实现了一个模板方法。这个模板方法通常是一个详细方法,它给出了一个顶级逻辑的骨架。而逻辑的组成步骤在对应的抽象操作中。推迟到子类实现。顶级逻辑也有可能调用一些详细方法。

  详细模板(Concrete Template)角色又例如以下责任:

  ■  实现父类所定义的一个或多个抽象方法。它们是一个顶级逻辑的组成步骤。

  ■  每个抽象模板角色都能够有随意多个详细模板角色与之相应,而每个详细模板角色都能够给出这些抽象方法(也就是顶级逻辑的组成步骤)的不同实现,从而使得顶级逻辑的实现各不同样。

  源码

  抽象模板角色类,abstractMethod()、hookMethod()等基本方法是顶级逻辑的组成步骤,这个顶级逻辑由templateMethod()方法代表。

[java] view
plain
copyprint?

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间:2012-6-28 上午10:30:37
  5. *
  6. * @类说明 :抽象模板角色类,abstractMethod()、hookMethod()等基本方法是顶级逻辑的组成步骤,
  7. *            这个顶级逻辑由templateMethod()方法代表。

  8. */
  9. public abstract class AbstractTemplate {
  10. /**
  11. * 模板方法
  12. */
  13. public void templateMethod() {
  14. // 调用基本方法
  15. abstractMethod();
  16. hookMethod();
  17. concreteMethod();
  18. }
  19. /**
  20. * 基本方法的声明(由子类实现)必须由子类置换
  21. */
  22. protected abstract void abstractMethod();
  23. /**
  24. * 基本方法(空方法)能够由子类置换
  25. */
  26. protected void hookMethod() {
  27. }
  28. /**
  29. * 基本方法(已经实现)子类不能够动
  30. */
  31. private final void concreteMethod() {
  32. // 业务相关的代码
  33. }
  34. }

  详细模板角色类,实现了父类所声明的基本方法。abstractMethod()方法所代表的就是强制子类实现的剩余逻辑,而hookMethod()方法是可选择实现的逻辑,不是必须实现的。

[java] view
plain
copyprint" style="text-decoration:none; border:none; padding:0px; margin:0px 10px 0px 0px; font-size:9px; color:rgb(12,137,207); background-color:inherit">?

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间:2012-6-28 上午10:37:45
  5. *
  6. * @类说明 :详细模板角色类,实现了父类所声明的基本方法,//
  7. *      abstractMethod()方法所代表的就是强制子类实现的剩余逻辑。//
  8. *      而hookMethod()方法是可选择实现的逻辑,不是必须实现的。
  9. */
  10. public class ConcreteTemplate extends AbstractTemplate {
  11. // 基本方法的实现
  12. @Override
  13. public void abstractMethod() {
  14. // 业务相关的代码
  15. }
  16. // 重写父类的方法
  17. @Override
  18. public void hookMethod() {
  19. // 业务相关的代码
  20. }
  21. }

  模板模式的关键是:子类能够置换掉父类的可变部分,可是子类却不能够改变模板方法所代表的顶级逻辑。

  每当定义一个新的子类时,不要依照控制流程的思路去想,而应当依照“责任”的思路去想。

换言之,应当考虑哪些操作是必须置换掉的。哪些操作是能够置换掉的,以及哪些操作是不能够置换掉的。

使用模板模式能够使这些责任变得清晰。

模板方法模式中的方法

  模板方法中的方法能够分为两大类:模板方法和基本方法。

  模板方法

  一个模板方法是定义在抽象类中的,把基本操作方法组合在一起形成一个总算法或一个总行为的方法。

  一个抽象类能够有随意多个模板方法,而不限于一个。每个模板方法都能够调用随意多个详细方法。

  基本方法

  基本方法又能够分为三种:抽象方法(Abstract Method)、详细方法(Concrete Method)和钩子方法(Hook Method)。

  ●  抽象方法:一个抽象方法由抽象类声明,由详细子类实现。在Java语言里抽象方法以abstractkeyword标示。

  ●  详细方法:一个详细方法由抽象类声明并实现,而子类并不实现或置换。

  ●  钩子方法:一个钩子方法由抽象类声明并实现。而子类会加以扩展。通常抽象类给出的实现是一个空实现。作为方法的默认实现。

  在上面的样例中,AbstractTemplate是一个抽象类。它带有三个方法。当中abstractMethod()是一个抽象方法,它由抽象类声明为抽象方法,并由子类实现。hookMethod()是一个钩子方法,它由抽象类声明并提供默认实现。而且由子类置换掉。concreteMethod()是一个详细方法。它由抽象类声明并实现。

  默认钩子方法

  一个钩子方法经常由抽象类给出一个空实现作为此方法的默认实现。这样的空的钩子方法叫做“Do Nothing Hook”。显然。这样的默认钩子方法在缺省适配模式里面已经见过了。一个缺省适配模式讲的是一个类为一个接口提供一个默认的空实现。从而使得缺省适配类的子类不必像实现接口那样必须给出全部方法的实现,由于通常一个详细类并不须要全部的方法。

  命名规则

  命名规则是设计师之间赖以沟通的管道之中的一个,使用恰当的命名规则能够帮助不同设计师之间的沟通。

  钩子方法的名字应当以do開始,这是熟悉设计模式的Java开发者的标准做法。

在上面的样例中。钩子方法hookMethod()应当以do开头;在HttpServlet类中,也遵从这一命名规则,如doGet()、doPost()等方法。


使用场景

  考虑一个计算存款利息的样例。如果系统须要支持两种存款账号。即货币市场(Money Market)账号和定期存款(Certificate of Deposite)账号。这两种账号的存款利息是不同的。因此。在计算一个存户的存款利息额时,必须区分两种不同的账号类型。

  这个系统的总行为应当是计算出利息。这也就决定了作为一个模板方法模式的顶级逻辑应当是利息计算。

由于利息计算涉及到两个步骤:一个基本方法给出账号种类。还有一个基本方法给出利息百分比。这两个基本方法构成详细逻辑,由于账号的类型不同,所以详细逻辑会有所不同。

  显然,系统须要一个抽象角色给出顶级行为的实现,而将两个作为细节步骤的基本方法留给详细子类实现。因为须要考虑的账号有两种:一是货币市场账号,二是定期存款账号。系统的类结构例如以下图所看到的。

  源码

  抽象模板角色类

[java] view
plain
copyprint?

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间:2012-6-28 上午11:13:22
  5. *
  6. * @类说明 :抽象模板角色类
  7. */
  8. public abstract class Account {
  9. /**
  10. * 模板方法。计算利息数额
  11. *
  12. * @return 返回利息数额
  13. */
  14. public final String calculateInterest() {
  15. double interestRate = doCalculateInterestRate();
  16. String accountType = doCalculateAccountType();
  17. System.out.println(accountType);
  18. double amount = calculateAmount(accountType);
  19. return amount + "*" + interestRate+ "=" + (amount * interestRate);
  20. }
  21. /**
  22. * 基本方法留给子类实现
  23. */
  24. protected abstract String doCalculateAccountType();
  25. /**
  26. * 基本方法留给子类实现
  27. */
  28. protected abstract double doCalculateInterestRate();
  29. /**
  30. * 基本方法,已经实现
  31. */
  32. private double calculateAmount(String accountType) {
  33. /**
  34. * 省略相关的业务逻辑
  35. */
  36. return 7243.00;
  37. }
  38. }

  详细模板角色类

[java] view
plain
copyprint?

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间:2012-6-28 上午11:14:13
  5. *
  6. * @类说明 :详细模板角色类- 定期账号
  7. */
  8. public class CDAccount extends Account {
  9. @Override
  10. protected String doCalculateAccountType() {
  11. return "CDA";
  12. }
  13. @Override
  14. protected double doCalculateInterestRate() {
  15. return 0.06;
  16. }
  17. }

[java] view
plain
copyprint?

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间:2012-6-28 上午11:13:49
  5. *
  6. * @类说明 :详细模板角色类- 货币市场账号
  7. */
  8. public class MoneyMarketAccount extends Account {
  9. @Override
  10. protected String doCalculateAccountType() {
  11. return "MMA";
  12. }
  13. @Override
  14. protected double doCalculateInterestRate() {
  15. return 0.045;
  16. }
  17. }

client类

[java] view
plain
copyprint?

  1. package com.bankht.Template;
  2. /**
  3. * @author: 特种兵—AK47
  4. * @创建时间:2012-6-28 上午11:14:30
  5. *
  6. * @类说明 :client类
  7. */
  8. public class Client {
  9. public static void main(String[] args) {
  10. Account account = new MoneyMarketAccount();
  11. System.out.println("货币市场账号的利息数额为:" + account.calculateInterest());
  12. account = new CDAccount();
  13. System.out.println("定期账号的利息数额为:" + account.calculateInterest());
  14. }
  15. }

执行一下:

[html] view
plain
copyprint?

  1. MMA
  2. 货币市场账号的利息数额为:7243.0*0.045=325.935
  3. CDA
  4. 定期账号的利息数额为:7243.0*0.06=434.58

模板方法模式在Servlet中的应用

  使用过Servlet的人都清楚,除了要在web.xml做对应的配置外,还需继承一个叫HttpServlet的抽象类。

HttpService类提供了一个service()方法,这种方法调用七个do方法中的一个或几个。完毕对client调用的响应。这些do方法须要由HttpServlet的详细子类提供。因此这是典型的模板方法模式。以下是service()方法的源码:

[java] view
plain
copyprint?

  1. protected void service(HttpServletRequest req, HttpServletResponse resp)
  2. throws ServletException, IOException {
  3. String method = req.getMethod();
  4. if (method.equals(METHOD_GET)) {
  5. long lastModified = getLastModified(req);
  6. if (lastModified == -1) {
  7. // servlet doesn‘t support if-modified-since, no reason
  8. // to go through further expensive logic
  9. doGet(req, resp);
  10. } else {
  11. long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
  12. if (ifModifiedSince < (lastModified / 1000 * 1000)) {
  13. // If the servlet mod time is later, call doGet()
  14. // Round down to the nearest second for a proper compare
  15. // A ifModifiedSince of -1 will always be less
  16. maybeSetLastModified(resp, lastModified);
  17. doGet(req, resp);
  18. } else {
  19. resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
  20. }
  21. }
  22. } else if (method.equals(METHOD_HEAD)) {
  23. long lastModified = getLastModified(req);
  24. maybeSetLastModified(resp, lastModified);
  25. doHead(req, resp);
  26. } else if (method.equals(METHOD_POST)) {
  27. doPost(req, resp);
  28. } else if (method.equals(METHOD_PUT)) {
  29. doPut(req, resp);
  30. } else if (method.equals(METHOD_DELETE)) {
  31. doDelete(req, resp);
  32. } else if (method.equals(METHOD_OPTIONS)) {
  33. doOptions(req,resp);
  34. } else if (method.equals(METHOD_TRACE)) {
  35. doTrace(req,resp);
  36. } else {
  37. //
  38. // Note that this means NO servlet supports whatever
  39. // method was requested, anywhere on this server.
  40. //
  41. String errMsg = lStrings.getString("http.method_not_implemented");
  42. Object[] errArgs = new Object[1];
  43. errArgs[0] = method;
  44. errMsg = MessageFormat.format(errMsg, errArgs);
  45. resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
  46. }
  47. }

  当然,这个service()方法也能够被子类置换掉。

  以下给出一个简单的Servlet样例:

  从上面的类图能够看出,TestServlet类是HttpServlet类的子类,而且置换掉了父类的两个方法:doGet()和doPost()。

[java] view
plain
copyprint?

  1. public class TestServlet extends HttpServlet {
  2. public void doGet(HttpServletRequest request, HttpServletResponse response)
  3. throws ServletException, IOException {
  4. System.out.println("using the GET method");
  5. }
  6. public void doPost(HttpServletRequest request, HttpServletResponse response)
  7. throws ServletException, IOException {
  8. System.out.println("using the POST method");
  9. }
  10. }

  从上面的样例能够看出这是一个典型的模板方法模式。

  HttpServlet担任抽象模板角色

    模板方法:由service()方法担任。

    基本方法:由doPost()、doGet()等方法担任。

  TestServlet担任详细模板角色

    TestServlet置换掉了父类HttpServlet中七个基本方法中的当中两个,各自是doGet()和doPost()。

本文借鉴:http://blog.csdn.net/m13666368773/article/details/7677374

书籍:中文版的  java设计模式第二版

时间: 2024-10-10 06:05:16

《Java设计模式》之模板方法模式的相关文章

Java设计模式之模板方法模式或者说模板设计模式(属于行为型)

抽象类,不变的代码写了,要变化的部分留给子类去实现: package 行为型_模板方法模式; //模板设计模式的意思是把不变定位部分写出来,变化的部分留给子类去实现 public abstract class GetTime { public long getTime() throws Exception{ long start = System.currentTimeMillis();//开始时间 /* //for循环 for(int i=0;i<10000;i++){ System.out.

java设计模式之模板方法模式

注意 本博客摘录于秦小波老师写的<设计模式之禅> 模板方法模式 汽车厂造悍马 假设我们是一个汽车公司,现在有客户来了,要求我们造悍马! 既然上级下来命令那就造呗,但是造悍马你得告诉我们汽车有什么功能啊,客户说了:"能启动车,能停止车,能响,能跑."好,功能出来了,开始造汽车了.类图如下: 抽象悍马模型代码如下: public abstract class HummerModel { /* * 首先,这个模型要能够被发动起来,别管是手摇发动,还是电力发动,反正 * 是要能够发

Java设计模式之模板方法模式(Template Method)

本文继续介绍23种设计模式系列之模板方法模式. 概述 模板方法模式是类的行为模式.准备一个抽象类,将部分逻辑以具体方法以及具体构造函数的形式实现,然后声明一些抽象方法来迫使子类实现剩余的逻辑.不同的子类可以以不同的方式实现这些抽象方法,从而对剩余的逻辑有不同的实现.这就是模板方法模式的用意. 比如定义一个操作中的算法的骨架,将步骤延迟到子类中.模板方法使得子类能够不去改变一个算法的结构即可重定义算法的某些特定步骤. 模式中的角色 抽象类(AbstractClass):实现了模板方法,定义了算法的

java设计模式(模板方法模式)

模板方法模式 定义一个操作中的算法的骨架,而将一些步骤延迟到子类中. 模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤.通俗的说的就是有很多相同的步骤的,在某一些地方可能有一些差别适合于这种模式,例如想要泡一杯茶或者一杯咖啡,第一步都是将水煮沸,第二部是加入咖啡或者茶,第三部就是将饮料倒入杯子中,第四部就是加入各种调味料.其中第一步和第三部都是一样的,这个就可以定义在基类,而第二步和第四步就是他们之间的差异就可以在具体的子类中去实现.下面就是代码实现. 定义抽象基类,为所有

大话设计模式_模板方法模式(Java代码)

模板方法模式:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中.模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤 简单描述:多个类的行为是差不多的,只是某些局部不一样,则交由父类中抽象出这些子类中相同的部分,父类中定义出不同的部分的接口(方法),这些不同部分的方法则由子类去实现,通过多态,实现代码的重用 大话设计模式中的截图: 例子代码: AbstractClass类: 1 package com.longsheng.templatemethod; 2 3 public

菜鸟译文(二)——使用Java泛型构造模板方法模式

如果你发现你有很多重复的代码,你可能会考虑用模板方法消除容易出错的重复代码.这里有一个例子:下面的两个类,完成了几乎相同的功能: 实例化并初始化一个Reader来读取CSV文件: 读取每一行并解析: 把每一行的字符填充到Product或Customer对象: 将每一个对象添加到Set里: 返回Set. 正如你看到的,只有有注释的地方是不一样的.其他所有步骤都是相同的. ProductCsvReader.java public class ProductCsvReader {       Set<

设计模式(8)--模板方法模式

关键词 :hook 钩子    Applet 中 init() destory() 为钩子,需要子类去实现. 新原则: 别调用我们,我们会调用你们    高层调用低层   低层不能调用高层. 目的 :封装算法 模板方法:子类决定如何实现算法中的步骤 策略:封装可互换的行为,然后使用委托来决定要采用哪一个行为 工厂方法:由子类决定实例化哪个具体类 OO原则:新原则上面 OO模式:模板方法模式:在一个方法中定义一个算法的骨架,而将一些步骤延迟到子类.模板方法使得子类可以在不改变算法的结构的情况下,重

【设计模式】——模板方法模式

模板方法模式,定义一个操作中的算法的骨架,而将一些步骤延迟到子类中.模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定的步骤.当我们要完成在某一细节层次一致的一个过程或一系列步骤,但其个别步骤在更详细的层次上的实现可能不同时,我们通常考虑用模板方法模式来处理. AbstractClas是抽象类,其实也就是一抽象模板,定义并实现了一个模板方法.这个模板方法一般是一个具体方法,它给出了一个顶级逻辑的骨架,而逻辑的组成步骤在相应的抽象操作中,推迟到子类实现.顶级逻辑也有可能调用一些具体

【大话设计模式】—— 模板方法模式

一.概念 上一篇文章刚刚讲了[大话设计模式]-- 原型模式,原型模式主要是通过Clone()方法,创建新的对象,免去了初始化的过程.模板方法模式也特别会"偷工减料",把不变的行为搬移到超类,去除子类中的重复代码,将代码的复用优势展现的淋漓尽致.它为我们提供了特定的结构和样式,我们只需关心填充数据内容就好,省心啊- 下面让我们来看一下它的准确定义: 模板方法(TemplateMethod)模式:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中.模板方法使得子类可以不改变一个算法的结构

JAVA设计模式之代理模式

学编程吧JAVA设计模式之代理模式发布了,欢迎通过xuebiancheng8.com来访问 一.概述 给某一个对象提供一个代理,并由代理对象来完成对原对象的访问.代理模式是一种对象结构型模式. 二.适用场景 当无法直接访问某个对象或访问某个对象存在困难时可以通过一个代理对象来间接访问,为了保证客户端使用的透明性,委托对象与代理对象需要实现相同的接口. 三.UML类图 四.参与者 1.接口类:Subject 它声明了真实访问者和代理访问者的共同接口,客户端通常需要针对接口角色进行编程. 2.代理类