设计模式笔记：模板方法模式

模板方法模式

我的理解：

这个模式，就是用继承的方式啊，在抽象类中定义好算法的固定步骤【模板方法】和需要的具体步骤实现的方法【基础方法】。

之后在子类中实现基础方法即可。因为模板方法已经确定了固定的流程。

---

2016年4月 

---

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

类型：行为类模式

类图：

结构角色：

• AbstractClass（抽象类）：在抽象类中定义了一系列基本操作(PrimitiveOperations)，这些基本操作可以是具体的，也可以是抽象的，每一个基本操作对应算法的一个步骤，在其子类中可以重定义或实现这些步骤。同时，在抽象类中实现了一个模板方法(Template Method)，用于定义一个算法的框架，模板方法不仅可以调用在抽象类中实现的基本方法，也可以调用在抽象类的子类中实现的基本方法，还可以调用其他对象中的方法。
  
• ConcreteClass（具体子类）：它是抽象类的子类，用于实现在父类中声明的抽象基本操作以完成子类特定算法的步骤，也可以覆盖在父类中已经实现的具体基本操作。
  

---

关于模板方法和基本方法：

 1. 模板方法

       一个模板方法是定义在抽象类中的、把基本操作方法组合在一起形成一个总算法或一个总行为的方法。这个模板方法定义在抽象类中，并由子类不加以修改地完全继承下来。模板方法是一个具体方法，它给出了一个顶层逻辑框架，而逻辑的组成步骤在抽象类中可以是具体方法，也可以是抽象方法。由于模板方法是具体方法，因此模板方法模式中的抽象层只能是抽象类，而不是接口。

         2. 基本方法

       基本方法是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：抽象方法(Abstract Method)、具体方法(Concrete Method)和钩子方法(Hook Method)。

       (1) 抽象方法：一个抽象方法由抽象类声明、由其具体子类实现。在C#语言里一个抽象方法以abstract关键字标识。

       (2) 具体方法：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。

       (3) 钩子方法：一个钩子方法由一个抽象类或具体类声明并实现，而其子类可能会加以扩展。通常在父类中给出的实现是一个空实现（可使用virtual关键字将其定义为虚函数），并以该空实现作为方法的默认实现，当然钩子方法也可以提供一个非空的默认实现。

---

示例：

模板方法模式中，抽象类的典型代码如下：

    
    

     
     

      
      abstract class AbstractClass 
     
     
     
     

      
      {
     
     
     
     

      
      //模板方法
     
     
     
     

      
      public void TemplateMethod() 
     
     
     
     

      
      {
     
     
     
     

      
              PrimitiveOperation1();
     
     
     
     

      
              PrimitiveOperation2();
     
     
     
     

      
              PrimitiveOperation3();
     
     
     
     

      
      }
     
     
     
     

      
       
     
     
     
     

      
      //基本方法—具体方法
     
     
     
     

      
      public void PrimitiveOperation1() 
     
     
     
     

      
      {
     
     
     
     

      
          //实现代码
     
     
     
     

      
      }
     
     
     
     

      
       
     
     
     
     

      
      //基本方法—抽象方法
     
     
     
     

      
          public abstract void PrimitiveOperation2();    
     
     
     
     

      
       
     
     
     
     

      
      //基本方法—钩子方法
     
     
     
     

      
      public virtual void PrimitiveOperation3()   
     
     
     
     

      
      {  }
     
     
     
     

      
      }
     
     
    
    

实例：

    
    

     
     

      
      //抽象模板
     
     
     
     

      
      public abstract class AbstractClass
     
     
     
     

      
      {
     
     
     
     

      
          protected abstract void doAnyting();
     
     
     
     

      
       
     
     
     
     

      
          protected abstract void doSomething();
     
     
     
     

      
       
     
     
     
     

      
          public void templateMethod()
     
     
     
     

      
          {
     
     
     
     

      
              doAnyting();
     
     
     
     

      
              doSomething();
     
     
     
     

      
          }
     
     
     
     

      
      }
     
     
     
     

      
       
     
     
     
     

      
      public class ConcreteClass1 extends AbstractClass
     
     
     
     

      
      {
     
     
     
     

      
          @Override
     
     
     
     

      
          protected void doAnyting()
     
     
     
     

      
          {
     
     
     
     

      
              System.out.println("do class1 anything");
     
     
     
     

      
          }
     
     
     
     

      
       
     
     
     
     

      
          @Override
     
     
     
     

      
          protected void doSomething()
     
     
     
     

      
          {
     
     
     
     

      
              System.out.println("do class1 something");
     
     
     
     

      
          }
     
     
     
     

      
      }
     
     
     
     

      
       
     
     
     
     

      
      public class ConcreteClass2 extends AbstractClass
     
     
     
     

      
      {
     
     
     
     

      
          @Override
     
     
     
     

      
          protected void doAnyting()
     
     
     
     

      
          {
     
     
     
     

      
              System.out.println("do class2 anything");
     
     
     
     

      
          }
     
     
     
     

      
       
     
     
     
     

      
          @Override
     
     
     
     

      
          protected void doSomething()
     
     
     
     

      
          {
     
     
     
     

      
              System.out.println("do class2 something");
     
     
     
     

      
          }
     
     
     
     

      
      }
     
     
     
     

      
       
     
     
     
     

      
      public class Client
     
     
     
     

      
      {
     
     
     
     

      
          public static void main(final String[] args)
     
     
     
     

      
          {
     
     
     
     

      
              final AbstractClass c1 = new ConcreteClass1();
     
     
     
     

      
              final AbstractClass c2 = new ConcreteClass2();
     
     
     
     

      
              c1.templateMethod();
     
     
     
     

      
              c2.templateMethod();
     
     
     
     

      
          }
     
     
     
     

      
      }
     
     
     
     

      
       
     
     
     
     

      
      结果：
     
     
     
     

      
      do class1 anything
     
     
     
     

      
      do class1 something
     
     
     
     

      
      do class2 anything
     
     
     
     

      
      do class2 something