模板方法模式的定义和组成：

模板方法模式是一种只需使用继承就可以实现的非常简单的模式。 
模板方法模式由两部分结构组成，第一部分是抽象父类，第二部分是具体的实现子类。通常在抽象父类中封装了子类的算法框架，包括实现一些公共方法以及封装子类中所有方法的执行顺 
序。子类通过继承这个抽象类，也继承了整个算法结构，并且可以选择重写父类的方法。

假如我们有一些平行的子类，各个子类之间有一些相同的行为，也有一些不同的行为。如果相同和不同的行为都混合在各个子类的实现中，说明这些相同的行为会在各个子类中重复出现。但实际上，相同的行为可以被搬移到另外一个单一的地方，模板方法模式就是为解决这个问题而生的。在模板方法模式中，子类实现中的相同部分被上移到父类中，而将不同的部分留待子类来实现。这也很好地体现了泛化的思想。

先泡一杯咖啡：

首先，我们先来泡一杯咖啡，如果没有什么太个性化的需求，泡咖啡的步骤通常如下： 
(1) 把水煮沸 
(2) 用沸水冲泡咖啡 
(3) 把咖啡倒进杯子 
(4) 加糖和牛奶 
通过下面这段代码，我们就能得到一杯香浓的咖啡：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <script>
  9.         var Coffee = function(){};
  10.         Coffee.prototype.boilWater = function(){
  11.             console.log( '把水煮沸' );
  12.         };
  13.         Coffee.prototype.brewCoffeeGriends = function(){
  14.             console.log( '用沸水冲泡咖啡' );
  15.         };
  16.         Coffee.prototype.pourInCup = function(){
  17.             console.log( '把咖啡倒进杯子' );
  18.         };
  19.         Coffee.prototype.addSugarAndMilk = function(){
  20.             console.log( '加糖和牛奶' );
  21.         };
  22.         Coffee.prototype.init = function(){
  23.             this.boilWater();
  24.             this.brewCoffeeGriends();
  25.             this.pourInCup();
  26.             this.addSugarAndMilk();
  27.         };
  28.         var coffee = new Coffee();
  29.         coffee.init();
  30.     </script>
  31. </body>
  32. </html>
  1.  

泡一壶茶：

接下来，开始准备我们的茶，泡茶的步骤跟泡咖啡的步骤相差并不大： 
(1) 把水煮沸 
(2) 用沸水浸泡茶叶 
(3) 把茶水倒进杯子 
(4) 加柠檬 
同样用一段代码来实现泡茶的步骤：

  1. var Tea = function(){};
  2. Tea.prototype.boilWater = function(){
  3.     console.log( '把水煮沸' );
  4. };
  5. Tea.prototype.steepTeaBag = function(){
  6.     console.log( '用沸水浸泡茶叶' );
  7. };
  8. Tea.prototype.pourInCup = function(){
  9.     console.log( '把茶水倒进杯子' );
  10. };
  11. Tea.prototype.addLemon = function(){
  12.     console.log( '加柠檬' );
  13. };
  14. Tea.prototype.init = function(){
  15.     this.boilWater();
  16.     this.steepTeaBag();
  17.     this.pourInCup();
  18.     this.addLemon();
  19. };
  20. var tea = new Tea();
  21. tea.init();
  1.  

分离出共同点：

  1. var Beverage = function(){};
  2. Beverage.prototype.boilWater = function(){
  3. console.log( '把水煮沸' );
  4. };
  5. Beverage.prototype.brew = function(){
  6.     throw new Error( '子类必须重写 brew 方法' );
  7.     }; // 空方法，应该由子类重写
  8. Beverage.prototype.pourInCup = function(){
  9.     throw new Error( '子类必须重写 pourInCup  方法' );
  10.     }; // 空方法，应该由子类重写
  11. Beverage.prototype.addCondiments = function(){
  12.     throw new Error( '子类必须重写 addCondiments 方法' );
  13.     }; // 空方法，应该由子类重写
  14. Beverage.prototype.init = function(){
  15.     this.boilWater();
  16.     this.brew();
  17.     this.pourInCup();
  18.     this.addCondiments();
  19. };

创建 Coffee 子类和 Tea 子类：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <script>
  9.         var Beverage = function(){};
  10.         Beverage.prototype.boilWater = function(){
  11.             console.log( '把水煮沸' );
  12.         };
  13.         Beverage.prototype.brew = function(){}; // 空方法，应该由子类重写
  14.         Beverage.prototype.pourInCup = function(){}; // 空方法，应该由子类重写
  15.         Beverage.prototype.addCondiments = function(){}; // 空方法，应该由子类重写
  16.         Beverage.prototype.init = function(){
  17.             this.boilWater();
  18.             this.brew();
  19.             this.pourInCup();
  20.             this.addCondiments();
  21.         };
  22.  
  23.         var Coffee = function(){};
  24.         Coffee.prototype = new Beverage();
  25.         Coffee.prototype.brew = function(){
  26.             console.log( '用沸水冲泡咖啡' );
  27.         };
  28.         Coffee.prototype.pourInCup = function(){
  29.             console.log( '把咖啡倒进杯子' );
  30.         };
  31.         Coffee.prototype.addCondiments = function(){
  32.             console.log( '加糖和牛奶' );
  33.         };
  34.         var Coffee = new Coffee();
  35.         Coffee.init();
  36.     </script>
  37. </body>
  38. </html>

本章一直讨论的是模板方法模式，那么在上面的例子中，到底谁才是所谓的模板方法呢？答案是 Beverage.prototype.init 。

Beverage.prototype.init 被称为模板方法的原因是，该方法中封装了子类的算法框架，它作为一个算法的模板，指导子类以何种顺序去执行哪些方法。在 Beverage.prototype.init 方法中， 
算法内的每一个步骤都清楚地展示在我们眼前。

模板方法模式的使用场景:

在 Web开发中也能找到很多模板方法模式的适用场景，比如我们在构建一系列的 UI组件， 
这些组件的构建过程一般如下所示： 
(1) 初始化一个 div容器； 
(2) 通过 ajax请求拉取相应的数据； 
(3) 把数据渲染到 div容器里面，完成组件的构造； 
(4) 通知用户组件渲染完毕。

我们看到，任何组件的构建都遵循上面的 4 步，其中第(1)步和第(4)步是相同的。第(2)步不同的地方只是请求 ajax的远程地址，第(3)步不同的地方是渲染数据的方式。

于是我们可以把这 4个步骤都抽象到父类的模板方法里面，父类中还可以顺便提供第(1)步和第(4)步的具体实现。当子类继承这个父类之后，会重写模板方法里面的第(2)步和第(3)步。

添加钩子

通过模板方法模式，我们在父类中封装了子类的算法框架。这些算法框架在正常状态下是适用于大多数子类的，但如果有一些特别“个性”的子类呢？比如我们在饮料类 Beverage 中封装了 
饮料的冲泡顺序： 
(1) 把水煮沸 
(2) 用沸水冲泡饮料 
(3) 把饮料倒进杯子 
(4) 加调料 
这 4个冲泡饮料的步骤适用于咖啡和茶，在我们的饮料店里，根据这 4个步骤制作出来的咖啡和茶，一直顺利地提供给绝大部分客人享用。但有一些客人喝咖啡是不加调料（糖和牛奶）的。既然 Beverage 作为父类，已经规定好了冲泡饮料的 4个步骤，那么有什么办法可以让子类不受这个约束呢？

钩子方法（ hook ）可以用来解决这个问题，放置钩子是隔离变化的一种常见手段。我们在父类中容易变化的地方放置钩子，钩子可以有一个默认的实现，究竟要不要“挂钩”，这由子类自行决定。钩子方法的返回结果决定了模板方法后面部分的执行步骤，也就是程序接下来的走向，这样一来，程序就拥有了变化的可能。在这个例子里，我们把挂钩的名字定为customerWantsCondiments ，接下来将挂钩放入 Beverage 
类，看看我们如何得到一杯不需要糖和牛奶的咖啡，代码如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <script>
  9.         var Beverage = function(){};
  10.         Beverage.prototype.boilWater = function(){
  11.             console.log( '把水煮沸' );
  12.         };
  13.         Beverage.prototype.brew = function(){
  14.             throw new Error( '子类必须重写 brew 方法' );
  15.         };
  16.         Beverage.prototype.pourInCup = function(){
  17.             throw new Error( '子类必须重写 pourInCup 方法' );
  18.         };
  19.         Beverage.prototype.addCondiments = function(){
  20.             throw new Error( '子类必须重写 addCondiments 方法' );
  21.         };
  22.         Beverage.prototype.customerWantsCondiments = function(){
  23.             return true; // 默认需要调料
  24.         };
  25.         Beverage.prototype.init = function(){
  26.             this.boilWater();
  27.             this.brew();
  28.             this.pourInCup();
  29.             if ( this.customerWantsCondiments() ){ // 如果挂钩返回 true，则需要调料
  30.                 this.addCondiments();
  31.             }
  32.         };
  33.         var CoffeeWithHook = function(){};
  34.         CoffeeWithHook.prototype = new Beverage();
  35.         CoffeeWithHook.prototype.brew = function(){
  36.             console.log( '用沸水冲泡咖啡' );
  37.         };
  38.         CoffeeWithHook.prototype.pourInCup = function(){
  39.             console.log( '把咖啡倒进杯子' );
  40.         };
  41.         CoffeeWithHook.prototype.addCondiments = function(){
  42.             console.log( '加糖和牛奶' );
  43.         };
  44.         CoffeeWithHook.prototype.customerWantsCondiments = function(){
  45.             return window.confirm( '请问需要调料吗？' );
  46.         };
  47.         var coffeeWithHook = new CoffeeWithHook();
  48.         coffeeWithHook.init();
  49.     </script>
  50. </body>
  51. </html>
  1.  

真的需要“继承”吗？

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <script>
  9.         var Beverage = function( param ){
  10.             var boilWater = function(){
  11.                 console.log( '把水煮沸' );
  12.             };
  13.             var brew = param.brew || function(){
  14.                     throw new Error( '必须传递 brew 方法' );
  15.                 };
  16.             var pourInCup = param.pourInCup || function(){
  17.                     throw new Error( '必须传递 pourInCup 方法' );
  18.                 };
  19.             var addCondiments = param.addCondiments || function(){
  20.                     throw new Error( '必须传递 addCondiments 方法' );
  21.                 };
  22.             var F = function(){};
  23.             F.prototype.init = function(){
  24.                 boilWater();
  25.                 brew();
  26.                 pourInCup();
  27.                 addCondiments();
  28.             };
  29.             return F;
  30.         };
  31.         var Coffee = Beverage({
  32.             brew: function(){
  33.                 console.log( '用沸水冲泡咖啡' );
  34.             },
  35.             pourInCup: function(){
  36.                 console.log( '把咖啡倒进杯子' );
  37.             },
  38.             addCondiments: function(){
  39.                 console.log( '加糖和牛奶' );
  40.             }
  41.         });
  42.         var Tea = Beverage({
  43.             brew: function(){
  44.                 console.log( '用沸水浸泡茶叶' );
  45.             },
  46.             pourInCup: function(){
  47.                 console.log( '把茶倒进杯子' );
  48.             },
  49.             addCondiments: function(){
  50.                 console.log( '加柠檬' );
  51.             }
  52.         });
  53.         var coffee = new Coffee();
  54.         coffee.init();
  55.         var tea = new Tea();
  56.         tea.init();
  57.     </script>
  58. </body>
  59. </html>
  1.  

js之模板方法模式的更多相关文章

  1. js设计模式——6.模板方法模式与职责链模式

    js设计模式——6.模板方法模式与职责链模式 职责链模式

  2. JS 设计模式七 -- 模板方法模式

    概念 模板方法模式是一直昂只需使用继承就可以实现的非常简单的模式. 模板方法模式由两部分结构组成,第一部分是抽象父类,第二部分是具体实现的子类. 实现 模板方法模式一般的实现方式为继承. // 体育运 ...

  3. js设计模式（七）---模板方法模式

    模板方法模式 模板方法模式是一种只需要继承就可以实现的非常简单的模式. 模板方法模式是由两部分组成,第一部分是抽象父类,第二部分是具体实现的子类, 主要适用在同级的子类具有相同的行为放在父类中实现,而 ...

  4. JS设计模式（8）模板方法模式

    什么是模板方法模式? 定义:定义一个操作中的算法的骨架,而将一些步骤延迟到子类中.模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤. 主要解决:一些方法通用,却在每一个子类都重新 ...

  5. javascript模板方法模式

    一:什么是模板方法模式: 模板方法模式由二部分组成,第一部分是抽象父类,第二部分是具体实现的子类,一般的情况下是抽象父类封装了子类的算法框架,包括实现一些公共方法及封装子类中所有方法的执行顺序,子类可 ...

  6. javascript设计模式与开发实践阅读笔记（11）—— 模板方法模式

    模板方法模式: 由两部分结构组成,第一部分是抽象父类,第二部分是具体的实现子类.通常在抽象父类中封装了子类的算法框架,包括实现一些公共方法以及封装子类中所有方法的执行顺序.子类通过继承这个抽象类,也继 ...

  7. 设计模式(九): 从醋溜土豆丝和清炒苦瓜中来学习"模板方法模式"(Template Method Pattern)

    今天是五.四青年节,祝大家节日快乐.看着今天这标题就有食欲,夏天到了,醋溜土豆丝和清炒苦瓜适合夏天吃,好吃不上火.这两道菜大部分人都应该吃过,特别是醋溜土豆丝,作为“鲁菜”的代表作之一更是为大众所熟知 ...

  8. 设计模式（十四）模板方法模式（Template Pattern）

    一.引言 提到模板,大家肯定不免想到生活中的“简历模板”.“论文模板”.“Word中模版文件”等,在现实生活中,模板的概念就是——有一个规定的格式,然后每个人都可以根据自己的需求或情况去更新它,例如简 ...

  9. C#设计模式-模板方法模式

    提到模板,大家肯定不免想到生活中的“简历模板”.“论文模板”.“Word中模版文件”等,在现实生活中,模板的概念就是——有一个规定的格式,然后每个人都可以根据自己的需求或情况去更新它,例如简历模板,下 ...

随机推荐

  1. tp5 微信授权

    protected $appid = '****************'; //微信 appidprotected $appsecrt = '******************'; //微信 ap ...

  2. Linux服务器安装系统之1-LSI阵列卡raid5配置方法

  3. PAT Advanced 1007 Maximum Subsequence Sum (25 分)

    Given a sequence of K integers { N​1​​, N​2​​, ..., N​K​​ }. A continuous subsequence is defined to ...

  4. VB学习一

    一.基础函数 CStr() 函数转化表达式为一个字符串 Trim() 移除字符串两侧的空白字符串或者其他预定义字符 成功:返回删除后的字符串 失败:返回空字符串 VBA.Mid(string,star ...

  5. Linux日常之显示文件总结

    1. 将文件file1.file2的内容都显示出来,并显示行号 cat -n file1 file2 2. 将文件file1.file2中带有字符'h'的行显示出来 cat -n file1 file ...

  6. 两张图理解nodeJS

  7. php内置函数分析array_diff()

    PHP_FUNCTION(array_diff) { zval *args; int argc, i; uint32_t num; HashTable exclude; zval *value; ze ...

  8. 前端之CSS：CSS选择器

    前端之css样式(选择器)... 一.css概述 CSS是Cascading Style Sheets的简称,中文称为层叠样式表,对html标签的渲染和布局 CSS 规则由两个主要的部分构成:选择器, ...

  9. docker for windows 中挂载文件到容器

    docker for windows版本: 宿主机:windows10 场景: 容器是基于microsoft/donet的webapi 想把宿主机的文件挂载到容器中,比方说:a.txt 命令如下: d ...

  10. R 保存图片——tiff

    tiff(filename = "c:\\aaa.tiff", res = 800, pointsize = 2) plot(1:100) dev.off() tiff(file= ...