Template Method

定义：在抽象类中定义关于操作的算法的骨架（相应的操作方法以及这些方法的执行顺序或逻辑），相应的子类可以重写符合自己需求的操作方法。
作用：将通用算法抽象出来，再由子类去重写

  1. /**
  2.  * The Abstract Class defines a template method that contains a skeleton of some
  3.  * algorithm, composed of calls to (usually) abstract primitive operations.
  4.  *
  5.  * Concrete subclasses should implement these operations, but leave the template
  6.  * method itself intact.
  7.  */
  8. abstract class AbstractClass {
  9.     /**
  10.      * The template method defines the skeleton of an algorithm.
  11.      */
  12.     public templateMethod(): void {
  13.         this.baseOperation1();
  14.         this.requiredOperations1();
  15.         this.baseOperation2();
  16.         this.hook1();
  17.         this.requiredOperation2();
  18.         this.baseOperation3();
  19.         this.hook2();
  20.     }
  22.     /**
  23.      * These operations already have implementations.
  24.      */
  25.     protected baseOperation1(): void {
  26.         console.log('AbstractClass says: I am doing the bulk of the work');
  27.     }
  29.     protected baseOperation2(): void {
  30.         console.log('AbstractClass says: But I let subclasses override some operations');
  31.     }
  33.     protected baseOperation3(): void {
  34.         console.log('AbstractClass says: But I am doing the bulk of the work anyway');
  35.     }
  37.     /**
  38.      * These operations have to be implemented in subclasses.
  39.      */
  40.     protected abstract requiredOperations1(): void;
  42.     protected abstract requiredOperation2(): void;
  44.     /**
  45.      * These are "hooks." Subclasses may override them, but it's not mandatory
  46.      * since the hooks already have default (but empty) implementation. Hooks
  47.      * provide additional extension points in some crucial places of the
  48.      * algorithm.
  49.      */
  50.     protected hook1(): void { }
  52.     protected hook2(): void { }
  53. }
  55. /**
  56.  * Concrete classes have to implement all abstract operations of the base class.
  57.  * They can also override some operations with a default implementation.
  58.  */
  59. class ConcreteClass1 extends AbstractClass {
  60.     protected requiredOperations1(): void {
  61.         console.log('ConcreteClass1 says: Implemented Operation1');
  62.     }
  64.     protected requiredOperation2(): void {
  65.         console.log('ConcreteClass1 says: Implemented Operation2');
  66.     }
  67. }
  69. /**
  70.  * Usually, concrete classes override only a fraction of base class' operations.
  71.  */
  72. class ConcreteClass2 extends AbstractClass {
  73.     protected requiredOperations1(): void {
  74.         console.log('ConcreteClass2 says: Implemented Operation1');
  75.     }
  77.     protected requiredOperation2(): void {
  78.         console.log('ConcreteClass2 says: Implemented Operation2');
  79.     }
  81.     protected hook1(): void {
  82.         console.log('ConcreteClass2 says: Overridden Hook1');
  83.     }
  84. }
  86. /**
  87.  * The client code calls the template method to execute the algorithm. Client
  88.  * code does not have to know the concrete class of an object it works with, as
  89.  * long as it works with objects through the interface of their base class.
  90.  */
  91. function clientCode(abstractClass: AbstractClass) {
  92.     // ...
  93.     abstractClass.templateMethod();
  94.     // ...
  95. }
  97. console.log('Same client code can work with different subclasses:');
  98. clientCode(new ConcreteClass1());
  99. console.log('');
  101. console.log('Same client code can work with different subclasses:');
  102. clientCode(new ConcreteClass2());

参考资料

  1. 通俗易懂系列 | 设计模式（一）：模板模式
  2. 模板方法模式