设计模式(5)——模板方法

最新推荐文章于 2021-01-07 10:30:14 发布
最新推荐文章于 2021-01-07 10:30:14 发布
阅读量556 收藏
点赞数
分类专栏： 设计模式

模板方法

原文地址1

原文地址2

一、模板方法模式的定义

     模板方法模式（TemplateMethod Pattern）其定义如下：

     Define theskeleton of an algorithm in an operation, deferring some steps to subclasses.Template Method lets subclasses redefine certain steps of an algorithm withoutchanging the algorithm's structure。

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

 

通常我们会遇到这样的一个问题：我们知道一个算法所需的关键步骤，并确定了这些步骤的执行顺序。但是某些步骤的具体实现是未知的，或者说某些步骤的实现与具体的环境相关。模板方法模式把我们不知道具体实现的步骤封装成抽象方法，提供一个按正确顺序调用它们的具体方法(这些具体方法统称为“模板方法”),这样构成一个抽象基类。子类通过继承这个抽象基类去实现各个步骤的抽象方法，而工作流程却由父类控制。

二、引入例子

生产悍马车，悍马车有两个型号，H1和H2，

抽象悍马模型    

在抽象类中，我们定义了悍马模型都必须具有的特质：能够启动、停止，喇叭会响，引擎可以轰鸣，

[java]  view plain copy print ?
  1. public abstract class HummerModel {  
  2.   
  3.     public abstract void start();  
  4.   
  5.     public abstract void stop();  
  6.   
  7.     public abstract void alarm();  
  8.   
  9.     public abstract void engineBoom();  
  10.   
  11.     public abstract void run();  
  12.   
  13. }  

H1型号悍马模型

[java]  view plain copy print ?
  1. public class HummerH1Model extends HummerModel {  
  2.   
  3.     //H1型号的悍马车鸣笛  
  4.   
  5.     public void alarm() {  
  6.   
  7.         System.out.println("悍马H1鸣笛...");  
  8.   
  9.     }  
  10.   
  11.     //引擎轰鸣声  
  12.   
  13.     public void engineBoom() {  
  14.   
  15.         System.out.println("悍马H1引擎声音是这样在...");  
  16.   
  17.     }  
  18.   
  19.     //汽车发动  
  20.   
  21.     public void start() {  
  22.   
  23.         System.out.println("悍马H1发动...");  
  24.   
  25.     }  
  26.   
  27.     //停车  
  28.   
  29.     public void stop() {  
  30.   
  31.         System.out.println("悍马H1停车...");  
  32.   
  33.     }  
  34.   
  35.     //开动起来  
  36.   
  37.     public void run() {  
  38.   
  39.         //先发动汽车  
  40.   
  41.         this.start();  
  42.   
  43.         //引擎开始轰鸣  
  44.   
  45.         this.engineBoom();  
  46.   
  47.         //然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭  
  48.   
  49.         this.alarm();  
  50.   
  51.         //到达目的地就停车  
  52.   
  53.         this.stop();  
  54.   
  55.     }  
  56.   
  57. }  

H2型号悍马模型

[java]  view plain copy print ?
  1. public class HummerH2Model extends HummerModel {  
  2.   
  3.     //H2型号的悍马车鸣笛  
  4.   
  5.     public void alarm() {  
  6.   
  7.         System.out.println("悍马H2鸣笛...");  
  8.   
  9.     }  
  10.   
  11.     //引擎轰鸣声  
  12.   
  13.     public void engineBoom() {  
  14.   
  15.         System.out.println("悍马H2引擎声音是这样在...");  
  16.   
  17.     }  
  18.   
  19.     //汽车发动  
  20.   
  21.     public void start() {  
  22.   
  23.         System.out.println("悍马H2发动...");  
  24.   
  25.     }  
  26.   
  27.     //停车  
  28.   
  29.     public void stop() {  
  30.   
  31.         System.out.println("悍马H2停车...");  
  32.   
  33.     }  
  34.   
  35.     //开动起来  
  36.   
  37.     public void run() {  
  38.   
  39.         //先发动汽车  
  40.   
  41.         this.start();  
  42.   
  43.         //引擎开始轰鸣  
  44.   
  45.         this.engineBoom();  
  46.   
  47.         //然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭  
  48.   
  49.         this.alarm();  
  50.   
  51.         //到达目的地就停车  
  52.   
  53.         this.stop();  
  54.   
  55.     }  
  56.   
  57. }  

程序编写到这里，已经发现问题了，两个实现类的run()方法都是完全相同的，那这个run()方法的实现应该出现在抽象类，不应该在实现类上，抽象是所有子类的共性封装。

注意在软件开发过程中，如果相同的一段代码拷贝过两次，就需要对设计产生怀疑，架构师要明确的说明为什么相同的逻辑要出现两次或更多次。

应用模板方法修改悍马模型

[java]  view plain copy print ?
  1. public abstract class HummerModel {  
  2.   
  3.     public abstract void start();  
  4.   
  5.     public abstract void stop();  
  6.   
  7.     public abstract void alarm();  
  8.   
  9.     public abstract void engineBoom();  
  10.   
  11.     public void run() {  
  12.   
  13.         //先发动汽车  
  14.   
  15.         this.start();  
  16.   
  17.         //引擎开始轰鸣  
  18.   
  19.         this.engineBoom();  
  20.   
  21.         //然后就开始跑了，跑的过程中遇到一条狗挡路，就按喇叭  
  22.   
  23.         this.alarm();  
  24.   
  25.         //到达目的地就停车  
  26.   
  27.         this.stop();  
  28.   
  29.     }  
  30.   
  31. }  

抽象的悍马模型上已经定义了run方法的执行规则，先启动，然后引擎立刻轰鸣，中间还要按一下喇叭，制造点噪声（要不就不是名车了），然后停车，它的两个具体实现类就不需要实现run方法了

场景类

[java]  view plain copy print ?
  1. public class Client {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.         //H1型号的悍马  
  6.   
  7.         HummerModel h1 = new HummerH1Model();  
  8.   
  9.         //H1模型演示  
  10.   
  11.         h1.run();  
  12.   
  13.     }  
  14.   
  15. }  

三、结构和通用代码

3.1、结构

准备一个抽象类，定义一个操作中的算法的骨架，将一些步骤声明为抽象方法迫使子类去实现。不同的子类可以以不同的方式实现这些抽象方法。模板模式的关键是：子类可以置换掉父类的可变部分，但是子类却不可以改变模板方法所代表的顶级逻辑。

抽象模板

模板方法模式确实非常简单，仅仅使用了Java的继承机制，但是它是一个应用非常广泛的模式。其中，AbstractClass叫做抽象模板，它的方法分为两类：

  • 基本方法 基本方法也叫做基本操作，是由子类实现的方法，并且在模板方法被调用。

  • 模板方法 可以有一个或几个，一般是一个具体方法，也就是一个骨架，实现对基本方法的调度，完成固定的逻辑。注意为了防止恶意的操作，一般模板方法都加上final关键字，不允许被覆写。

具体模板

     在类图中还有一个角色：具体模板，ConcreteClass1和ConcreteClass2属于具体模板，实现父类所定义的一个或多个抽象方法，也就是父类定义的基本方法在子类中得以实现。

3.2、通用代码

AbstractClass

[java]  view plain copy print ?
  1. public abstract class AbstractClass {  
  2.   
  3.     //基本方法  
  4.   
  5.     protected abstract void doSomething();  
  6.   
  7.     //基本方法  
  8.   
  9.     protected abstract void doAnything();  
  10.   
  11.     //模板方法  
  12.   
  13.     public void templateMethod() {  
  14.   
  15.         /* 
  16.          * 调用基本方法，完成相关的逻辑 
  17.          */  
  18.   
  19.         this.doAnything();  
  20.   
  21.         this.doSomething();  
  22.   
  23.     }  
  24.   
  25. }  

ConcreteClass1

[java]  view plain copy print ?
  1. public class ConcreteClass1 extends AbstractClass {  
  2.   
  3.     //实现基本方法  
  4.   
  5.     protected void doAnything() {  
  6.   
  7.         //业务逻辑处理  
  8.   
  9.     }  
  10.   
  11.     protected void doSomething() {  
  12.   
  13.         //业务逻辑处理  
  14.   
  15.     }  
  16.   
  17. }  

ConcreteClass2

[java]  view plain copy print ?
  1. public class ConcreteClass2 extends AbstractClass {  
  2.   
  3.     //实现基本方法  
  4.   
  5.     protected void doAnything() {  
  6.   
  7.         //业务逻辑处理  
  8.   
  9.     }  
  10.   
  11.     protected void doSomething() {  
  12.   
  13.         //业务逻辑处理  
  14.   
  15.     }  
  16.   
  17. }  

场景类

[java]  view plain copy print ?
  1. public class Client {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.         AbstractClass class1 = new ConcreteClass1();  
  6.   
  7.         AbstractClass class2 = new ConcreteClass2();  
  8.   
  9.         //调用模板方法  
  10.   
  11.         class1.templateMethod();  
  12.   
  13.         class2.templateMethod();  
  14.   
  15.     }  
  16.   
  17. }  

 

四、模板方法模式的应用

1. 模板方法模式的优点

  • 封装不变部分，扩展可变部分。

     把认为是不变部分的算法封装到父类实现，而可变部分的则可以通过继承来继续扩展。我们悍马模型例子中，是不是就非常容易扩展，例如增加一个H3型号的悍马模型，很容易呀，增加一个子类，实现父类的基本方法就可以了。

  • 提取公共部分代码，便于维护。

     我们例子中刚刚走过的弯路就是最好的证明，如果我们不抽取到父类中，任由这种散乱的代码发生，想想后果是什么样子？维护人员为了修正一个缺陷，需要到处查找类似的代码！

  • 行为控制交由子类来实现。

     基本方法是由子类实现的，因此子类可以通过扩展的方式增加相应的功能，符合开闭原则。

2. 模板方法模式的缺点

     按照我们设计习惯，抽象类负责声明最抽象、最一般的事物属性和方法，实现类完成具体的事物属性和方法，但是模板方法模式却颠倒了，抽象类定义了部分抽象方法，由子类实现，子类执行的结果影响了父类的结果，也就是子类对父类产生了影响，这在复杂的项目中，会带来代码阅读的难度，而且也会让新手产生不适感。

3. 模板方法模式的使用场景

    • 多个子类有公有的方法，并且逻辑基本相同时。
    • 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。
    • 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数（见“模板方法模式的扩展”）约束其行为。

4.板方法模式与对象的封装性

注意 抽象模版中的基本方法尽量设计为protected类型，符合迪米特原则，不需要暴露的属性或方法尽量不要设置为protected类型。实现类若非必要，尽量不要扩大父类中访问权限。

五、框架中的应用

模板方法在一些开源框架中应用非常很多，它提供了一个抽象类，然后开源框架写了一堆子类，在《XXX In Action》中就说明了，如果你需要扩展功能，可以继承了这个抽象类，然后覆写protected方法，再然后就是调用一个类似execute方法，就完成你的扩展开发，非常容易扩展的一种模式

（1） JUnit中的TestCase以及它的子类就是一个模板方法模式的例子。在TestCase这个抽象类中将整个测试的流程设置好，比如先执行setup方法初始化测试资源，再运行测试方法，然后再tearDown来释放测试资源。但是我们将在setup、tearDown里面作些什么？谁知道呢？！因此，这些步骤的具体实现都会延迟到子类中去，也就是我们实现的测试类中。

（2） Struts框架控制器的核心类RequestProcess里面的process方法也是采用了经典的模板方法模式，里面定义好了流程的步骤，而步骤里面的很多环节，我们都是可以重写的。

（3）模板方法模式在Servlet中的应用

使用过Servlet的人都清楚，除了要在web.xml做相应的配置外，还需继承一个叫HttpServlet的抽象类。HttpService类提供了一个service()方法，这个方法调用七个do方法中的一个或几个，完成对客户端调用的响应。这些do方法需要由HttpServlet的具体子类提供，因此这是典型的模板方法模式。下面是service()方法的源代码：

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

下面给出一个简单的Servlet例子：TestServlet类是HttpServlet类的子类，并且置换掉了父类的两个方法：doGet()和doPost()。

[java]  view plain copy print ?
  1. public class TestServlet extends HttpServlet {  
  2.   
  3.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
  4.             throws ServletException, IOException {  
  5.   
  6.         System.out.println("using the GET method");  
  7.   
  8.     }  
  9.   
  10.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
  11.             throws ServletException, IOException {  
  12.   
  13.         System.out.println("using the POST method");  
  14.     }  
  15.   
  16. }  

从上面的例子可以看出这是一个典型的模板方法模式。

　　HttpServlet担任抽象模板角色

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

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

　　TestServlet担任具体模板角色

　　　　TestServlet置换掉了父类HttpServlet中七个基本方法中的其中两个，分别是doGet()和doPost()。

六、带钩子函数的模板方法的引入

客户提出H1型号的悍马喇叭想让它响就响，H2型号的喇叭不要有声音。

类图似乎改动很小，在抽象类HummerModel中增加了一个实现方法isAlarm，确定各个型号的悍马是否需要声音，由各个实现类覆写该方法，

修改后的悍马模型

[java]  view plain copy print ?
  1. public abstract class HummerModel {  
  2.   
  3.     protected abstract void start();  
  4.   
  5.     protected abstract void stop();  
  6.   
  7.     protected abstract void alarm();  
  8.   
  9.     protected abstract void engineBoom();  
  10.   
  11.     final public void run() {  
  12.   
  13.         // 先发动汽车  
  14.   
  15.         this.start();  
  16.   
  17.         // 引擎开始轰鸣  
  18.   
  19.         this.engineBoom();  
  20.   
  21.         // 要让它叫的就是就叫，喇嘛不想让它响就不响  
  22.   
  23.         if (this.isAlarm()) {  
  24.   
  25.             this.alarm();  
  26.   
  27.         }  
  28.   
  29.         // 到达目的地就停车  
  30.   
  31.         this.stop();  
  32.   
  33.     }  
  34.   
  35.     // 钩子方法，默认喇叭是会响的  
  36.   
  37.     protected boolean isAlarm() {  
  38.   
  39.         return true;  
  40.   
  41.     }  
  42.   
  43. }  

在抽象类中，isAlarm是一个实现方法，其作用是模板方法根据其返回值决定是否要响喇叭，子类可以覆写该返回值，由于H1型号的喇叭是想让它响就响，不想让它响就不响，由人控制了

[java]  view plain copy print ?
  1. public class HummerH1Model extends HummerModel {  
  2.   
  3.     private boolean alarmFlag = true; //要响喇叭  
  4.   
  5.     protected void alarm() {  
  6.   
  7.         System.out.println("悍马H1鸣笛...");  
  8.   
  9.     }  
  10.   
  11.     protected void engineBoom() {  
  12.   
  13.         System.out.println("悍马H1引擎声音是这样在...");  
  14.   
  15.     }  
  16.   
  17.     protected void start() {  
  18.   
  19.         System.out.println("悍马H1发动...");  
  20.   
  21.     }  
  22.   
  23.     protected void stop() {  
  24.   
  25.         System.out.println("悍马H1停车...");  
  26.   
  27.     }  
  28.   
  29.     protected boolean isAlarm() {  
  30.   
  31.         return this.alarmFlag;  
  32.   
  33.     }  
  34.   
  35.     //要不要响喇叭，是有客户的来决定的  
  36.   
  37.     public void setAlarm(boolean isAlarm) {  
  38.   
  39.         this.alarmFlag = isAlarm;  
  40.   
  41.     }  
  42.   
  43. }  

H2型号的悍马是没有喇叭声响的

[java]  view plain copy print ?
  1. public class HummerH2Model extends HummerModel {  
  2.   
  3.     protected void alarm() {  
  4.   
  5.         System.out.println("悍马H2鸣笛...");  
  6.   
  7.     }  
  8.   
  9.     protected void engineBoom() {  
  10.   
  11.         System.out.println("悍马H2引擎声音是这样在...");  
  12.   
  13.     }  
  14.   
  15.     protected void start() {  
  16.   
  17.         System.out.println("悍马H2发动...");  
  18.   
  19.     }  
  20.   
  21.     protected void stop() {  
  22.   
  23.         System.out.println("悍马H2停车...");  
  24.   
  25.     }  
  26.   
  27.     //默认没有喇叭的  
  28.   
  29.     protected boolean isAlarm() {  
  30.   
  31.         return false;  
  32.   
  33.     }  
  34.   
  35. }  

Client

[java]  view plain copy print ?
  1. public class Client {  
  2.   
  3.     public static void main(String[] args) throws IOException {  
  4.   
  5.         System.out.println("-------H1型号悍马--------");  
  6.   
  7.         System.out.println("H1型号的悍马是否需要喇叭声响？0-不需要 1-需要");  
  8.   
  9.         String type = (new BufferedReader(new InputStreamReader(System.in))).readLine();  
  10.   
  11.         HummerH1Model h1 = new HummerH1Model();  
  12.   
  13.         if (type.equals("0")) {  
  14.   
  15.             h1.setAlarm(false);  
  16.   
  17.         }  
  18.   
  19.         h1.run();  
  20.   
  21.         System.out.println("\n-------H2型号悍马--------");  
  22.   
  23.         HummerH2Model h2 = new HummerH2Model();  
  24.   
  25.         h2.run();  
  26.   
  27.     }  
  28.   
  29. }  

H1型号的悍马是由客户自己控制是否要响喇叭，也就是说外界条件改变，影响到模板方法的执行，在我们的抽象类中isAlarm的返回值就是影响了模板方法的执行结果，该方法就叫做钩子方法(Hook Method)，有了钩子方法模板方法模式才算完美，大家可以想想，由子类的一个方法返回值决定决定公共部分的执行结果。

七、带钩子函数的模板方法的代码框架

这里涉及到两个角色：

抽象模板(Abstract Template)角色有如下责任：

　■定义了一个或多个抽象操作，以便让子类实现。这些抽象操作叫做基本操作，它们是一个顶级逻辑的组成步骤。

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

具体模板(Concrete Template)角色又如下责任：

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

  ■每一个抽象模板角色都可以有任意多个具体模板角色与之对应，而每一个具体模板角色都可以给出这些抽象方法（也就是顶级逻辑的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。

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

[java]  view plain copy print ?
  1. public abstract class AbstractTemplate {  
  2.     /** 
  3.      * 模板方法 
  4.      */  
  5.     public void templateMethod(){  
  6.         //调用基本方法  
  7.         abstractMethod();  
  8.         hookMethod();  
  9.         concreteMethod();  
  10.     }  
  11.     /** 
  12.      * 基本方法的声明（由子类实现） 
  13.      */  
  14.     protected abstract void abstractMethod();  
  15.     /** 
  16.      * 基本方法(空方法) 
  17.      */  
  18.     protected void hookMethod(){}  
  19.     /** 
  20.      * 基本方法（已经实现） 
  21.      */  
  22.     private final void concreteMethod(){  
  23.         //业务相关的代码  
  24.     }  
  25. }  

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

[java]  view plain copy print ?
  1. public class ConcreteTemplate extends AbstractTemplate{  
  2.     //基本方法的实现  
  3.     @Override  
  4.     public void abstractMethod() {  
  5.         //业务相关的代码  
  6.     }  
  7.     //重写父类的方法  
  8.     @Override  
  9.     public void hookMethod() {  
  10.         //业务相关的代码  
  11.     }  
  12. }  

模板模式的关键是：子类可以置换掉父类的可变部分，但是子类却不可以改变模板方法所代表的顶级逻辑。

　　每当定义一个新的子类时，不要按照控制流程的思路去想，而应当按照“责任”的思路去想。换言之，应当考虑哪些操作是必须置换掉的，哪些操作是可以置换掉的，以及哪些操作是不可以置换掉的。使用模板模式可以使这些责任变得清晰。

模板方法模式中的方法

　　模板方法中的方法可以分为两大类：模板方法和基本方法。

模板方法

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

　　一个抽象类可以有任意多个模板方法，而不限于一个。每一个模板方法都可以调用任意多个具体方法。

基本方法

基本方法又可以分为三种：抽象方法(Abstract Method)、具体方法(Concrete Method)和钩子方法(Hook Method)。

　　●抽象方法：一个抽象方法由抽象类声明，由具体子类实现。在Java语言里抽象方法以abstract关键字标示。

　　●具体方法：一个具体方法由抽象类声明并实现，而子类并不实现或置换。

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

　　在上面的例子中，AbstractTemplate是一个抽象类，它带有三个方法。其中abstractMethod()是一个抽象方法，它由抽象类声明为抽象方法，并由子类实现；hookMethod()是一个钩子方法，它由抽象类声明并提供默认实现，并且由子类置换掉。concreteMethod()是一个具体方法，它由抽象类声明并实现。

　　默认钩子方法

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

　　命名规则

　　命名规则是设计师之间赖以沟通的管道之一，使用恰当的命名规则可以帮助不同设计师之间的沟通。钩子方法的名字应当以do开始，这是熟悉设计模式的Java开发人员的标准做法。在上面的例子中，钩子方法hookMethod()应当以do开头；在HttpServlet类中，也遵从这一命名规则，如doGet()、doPost()等方法。

爱笑的余尔吖
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式——模板方法（template method）
净无邪博客
03-20 703
一、原理讲解 模板方法的核心定义一个算法的骨架，而将一些细节方法延迟到之类中实现。其中，算法骨架是不变的部分，细节方法是变化的部分。设计模式的核心思想就是将变化部分和不变部分有效隔离、耦合出来。该思路的实现重要利用c++多态特性，运行时刻，基类指针指向不同的父类，则运行该父类重写的函数（前提：基类中是虚函数）。实现步骤如下： 1.1定义一个抽象基类ABC； 1.2抽象基类ABC定义两个抽象方...
模板方法模式(模板模式)——钩子方法
笔记别偷看
12-15 3476
豆浆制作问题 编写制作豆浆的程序，说明如下: 制作豆浆的流程选材—>添加配料—>浸泡—>放到豆浆机打碎 通过添加不同的配料，可以制作出不同口味的豆浆 选材、浸泡和放到豆浆机打碎这几个步骤对于制作每种口味的豆浆都是一样的 请使用模板方法模式完成(说明：因为模板方法模式，比较简单，很容易就想到这个方案，因此就直接使用，不再使用传统的方案来引出模板方法模式) 模板方法模式基本介绍 基本介绍 模板方法模式（Template Method Pattern），又叫模板模式(Te
模板方法模式
weixin_30475039的博客
11-01 81
模板方法模式 模板方法模式：定义一个算法中的操作框架，而将一些步骤延迟到子类中。使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。（Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses re...
设计模式(5)---->模板方法
weixin_34258078的博客
05-30 92
模板方法 原文地址1 原文地址2 一、模板方法模式的定义      模板方法模式（TemplateMethod Pattern）其定义如下：      Define theskeleton of an algorithm in an operation, deferring some steps to subclasses.Template Method lets subclasses ...
设计模式：模板方法
hxt的博客
01-30 799
模板方法模式定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤 1、模板方法的主要角色 模板方法模式使用了Java的继承机制，其中，AbstractClass叫做抽象模板，它的方法分为两类： 基本方法：由子类实现的方法，并且在模板方法被调用 模板方法：实现对基本方法的调度，完成固定的逻辑 ConcreteClass1和Conc...
Java设计模式----模板方法模式（Template Method）
weixin_30570101的博客
10-29 126
1. 模板方法模式定义： 定义一个操作中的算法的框架，而将一些步骤延迟到子类中。是的子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。 2. 模板方法模式的实现很简单，其原理是Java的继承机制，它主要包含2个角色，抽象模板角色和具体模板角色 3. 通用示例代码： 抽象模板类： public abstract class Abstrac...
设计模式之模板方法模式（TemplateMethod）
热门推荐
Song's Blog
05-07 1万+
1.模板方法模式的概念 模板方法模式，定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。 2.模板方法模式的结构 AbstractClass：实现一个模板方法，定义了算法的骨架，具体子类将重定义PrimitiveOperation以实现一个算法的步骤。AbstractClass其实就是一个抽象模板，定义并实现...
Python设计模式之模板方法模式实例详解
12-24
本文实例讲述了Python设计模式之模板方法模式。分享给大家供大家参考，具体如下： ...设计模式——模板方法模式 模板方法模式(Template Method Pattern):定义一个操作中的算法骨架，将一些步骤延迟至子
设计模式——模板方法模式（ Template Method Pattern）
蜗牛的专栏
07-24 603
一、模板方法模式的定义 在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。 从定义可以看出，模板方法的本质是：封装算法。类图结构： 其中，templateMethod会调用抽象类中定义的一些抽象方法，或者已经实现（默认的具体实现）的方法（称之为“钩子”），子类（实现类）需要实现父类中的抽象方法，或者覆盖父类中已实现
详解C#设计模式编程中的模板方法模式使用
12-31
在设计模式中，模板方法模式中模板和生活中模板概念非常类似，下面让我们就详细介绍模板方法的定义，大家可以根据生活中模板的概念来理解模板方法的定义。 二、模板方法模式详细介绍 2.1 模板方法模式的定义 模板...
设计模式之模板方法模式（Template Method Pattern）
猎人在吃肉
03-15 382
文章目录一、模板方法模式的定义与特点1.1、定义：1.2、优点：1.3、缺点：二、模式的结构与实现三、家庭制作牛奶的示例3.1、制作牛奶的UML类图3.2、代码3.2.1、Milk（抽象类，表示牛奶）3.2.2、MilkWithRedBean（红豆味的牛奶）3.2.3、MilkWithPeanut（花生的牛奶）3.2.4、MilkWithPure（纯味的牛奶）3.2.5、Client 一、模板方法...
设计模式-模板方法模式Template Method(对象行为型)
justkong的博客
08-30 269
一、概述 定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 AbstractClass叫做抽象模板，它的方法分为两类： （1）原始方法，是由子类实现的方法，并且在模板方法被调用 （2）模板方法，可以有一个或几个，实现对原始方法的调度，完成固定的逻辑 class AbstractClass { public: ...
servlet中的dopost方法与doget方法
qq_39100560的博客
04-19 4784
问题：为什么在servet中的dopost方法中调用doget方法 最终我得到的最好的理解：仅仅考虑这是两个方法，都可以互相调用，在dopost中调用doget方法只是因为我们不知道浏览器发送的是什么请求，虽然协议不同，但实现的逻辑是相同的，所以可以直接调用。 下面进一步说明http中的get方法与post方法 doget： 一般来说我们是用不到doGet方法的，doGet方法提交表单的时候会在u...
Java设计模式之模板方法模式
C18298182575的博客
01-07 246
此文转载，请访问原文：https://www.cnblogs.com/canglg/p/10564739.html 4.模板方法模式 如果你有一个任务，在一个星期内制造10万悍马车模型，只考虑最基本的实现，不考虑太多别的问题，你会怎么做？ 既然不考虑扩展性，那就好办了，先按照最一般的经验设计类图，如下图所示 非常简单的实现，悍马车有两个型号，H1和H2。按照要求，只需要悍马模型，那就只给悍马模型，先写个抽象类，然后两个不同型号的实现类，通过简单的继承就可以实现业务要求。悍马模型的抽象类代码如下： 复制代码
学习笔记：各种设计模式的实现 以及其特点的详细解析
Mands_的博客
05-15 1915
一、软件设计模式的概念与意义 有关软件设计模式的定义很多，有些从模式的特点来说明，有些从模式的作用来说明，从以下两个方面来说明。 各种设计模式的详解与实现在最后一章节，有需要的小伙伴可以跳过前面的内容。 1. 软件设计模式的概念 软件设计模式（Software Design Pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。也就是说，它是解决特定问题的一系列套路，是前辈们的代码设计经验的
模板方法模式Template method（类行为型）
it_man的专栏
07-18 1584
今天重读了 模板方法 模式，温故而知新 了。 她是基于继承的代码复用的基本技术，她的结构和用法也是面向对象设计的核心。 java方面应用：selvert中就用到了。   命名规范：钩子方法的名字应以do开头。   大家自己去看资料会理解深些。 有问题可以在这里提问。   设计模式的有趣见解 :   TEMPLATE METHOD——看过《如何说服女生上床》这部经典文章吗？女生从认
模版方法模式
Lud的博客
08-24 151
文章目录1 模版方法模式的定义2 模版方法模式使用实例3 模版方法模式的应用3.1 模版方法模式的优点3.2 模板方法模式的缺点3.3 模板方法模式的使用场景模板方法模式的扩展 1 模版方法模式的定义 定义：定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。 模版方法的通用类图如下所示： 模版方法模式其实非常简单，仅...
行为模式之Template Method模式
多看多听多总结
12-23 513
1、意图 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。TemplateMethod使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 2、适用性 （1）一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现 （2）各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。 （3）控制子类扩展 3、参与者 （1）AbstractClass：定义抽
（九）模板方法模式
mjd的专栏
01-23 525
周三，9：00，我刚刚坐到位置，打开电脑准备开始干活。  “小三，小三，叫一下其它同事，到会议室，开会”老大跑过来吼，带着淫笑。还不等大家坐稳，老 大就开讲了,  “告诉大家一个好消息，昨天终于把牛叉模型公司的口子打开了，要我们做悍马模型，虽然是第一个 车辆模型，但是我们有能力，有信心做好，我们一定要…（中间省略 20 分钟的讲话，如果你听过领导人的 讲话，这个你应该能够续上） ” 
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值