3.9 模板方法 Template Method

本是古典何须时尚 2022-12-26 04:43 104阅读 0赞

**专业描述**  
模板方法模式是一种行为设计模式， 它在超类中定义了一个算法的框架， 允许子类在不修改结构的情况下重写算法的特定步骤。

**真实世界类比**  
模板方法可用于建造大量房屋。 标准房屋建造方案中可提供几个扩展点， 允许潜在房屋业主调整成品房屋的部分细节。

每个建造步骤 （例如打地基、 建造框架、 建造墙壁和安装水电管线等） 都能进行微调， 这使得成品房屋会略有不同。

**模板方法模式结构**  
![在这里插入图片描述][20201203111443153.png_pic_center]

1.  **抽象类 （AbstractClass）** 会声明作为算法步骤的方法， 以及依次调用它们的实际模板方法。 算法步骤可以被声明为 抽象类型， 也可以提供一些默认实现。
2.  **具体类 （ConcreteClass）** 可以重写所有步骤， 但不能重写模板方法自身。

**模板方法模式适合应用场景**

*  当你只希望客户端扩展某个特定算法步骤， 而不是整个算法或其结构时， 可使用模板方法模式。
 *  当多个类的算法除一些细微不同之外几乎完全一样时， 你可使用该模式。 但其后果就是， 只要算法发生变化， 你就可能需要修改所有的类。

**实现方式**

1.  分析目标算法， 确定能否将其分解为多个步骤。 从所有子类的角度出发， 考虑哪些步骤能够通用， 哪些步骤各不相同。
2.  创建抽象基类并声明一个模板方法和代表算法步骤的一系列抽象方法。 在模板方法中根据算法结构依次调用相应步骤。 可用 `final最终`修饰模板方法以防止子类对其进行重写。
3.  虽然可将所有步骤全都设为抽象类型， 但默认实现可能会给部分步骤带来好处， 因为子类无需实现那些方法。
4.  可考虑在算法的关键步骤之间添加钩子。
5.  为每个算法变体新建一个具体子类， 它必须实现所有的抽象步骤， 也可以重写部分可选步骤。

**其与策略模式的区别：**

模板方法基于继承机制： 它允许你通过扩展子类中的部分内容来改变部分算法。 [策略模式][Link 1]基于组合机制： 你可以通过对相应行为提供不同的策略来改变对象的部分行为。 模板方法在类层次上运作， 因此它是静态的。 策略在对象层次上运作， 因此允许在运行时切换行为。

C++算法示例：

/** * The Abstract Class defines a template method that contains a skeleton of some * algorithm, composed of calls to (usually) abstract primitive operations. * * Concrete subclasses should implement these operations, but leave the template * method itself intact. */
    class AbstractClass { 
      /** * The template method defines the skeleton of an algorithm. */
     public:
      void TemplateMethod() const { 
        this->BaseOperation1();
        this->RequiredOperations1();
        this->BaseOperation2();
        this->Hook1();
        this->RequiredOperation2();
        this->BaseOperation3();
        this->Hook2();
      }
      /** * These operations already have implementations. */
     protected:
      void BaseOperation1() const { 
        std::cout << "AbstractClass says: I am doing the bulk of the work\n";
      }
      void BaseOperation2() const { 
        std::cout << "AbstractClass says: But I let subclasses override some operations\n";
      }
      void BaseOperation3() const { 
        std::cout << "AbstractClass says: But I am doing the bulk of the work anyway\n";
      }
      /** * These operations have to be implemented in subclasses. */
      virtual void RequiredOperations1() const = 0;
      virtual void RequiredOperation2() const = 0;
      /** * These are "hooks." Subclasses may override them, but it's not mandatory * since the hooks already have default (but empty) implementation. Hooks * provide additional extension points in some crucial places of the * algorithm. */
      virtual void Hook1() const { }
      virtual void Hook2() const { }
    };
    /** * Concrete classes have to implement all abstract operations of the base class. * They can also override some operations with a default implementation. */
    class ConcreteClass1 : public AbstractClass { 
     protected:
      void RequiredOperations1() const override { 
        std::cout << "ConcreteClass1 says: Implemented Operation1\n";
      }
      void RequiredOperation2() const override { 
        std::cout << "ConcreteClass1 says: Implemented Operation2\n";
      }
    };
    /** * Usually, concrete classes override only a fraction of base class' operations. */
    class ConcreteClass2 : public AbstractClass { 
     protected:
      void RequiredOperations1() const override { 
        std::cout << "ConcreteClass2 says: Implemented Operation1\n";
      }
      void RequiredOperation2() const override { 
        std::cout << "ConcreteClass2 says: Implemented Operation2\n";
      }
      void Hook1() const override { 
        std::cout << "ConcreteClass2 says: Overridden Hook1\n";
      }
    };
    /** * The client code calls the template method to execute the algorithm. Client * code does not have to know the concrete class of an object it works with, as * long as it works with objects through the interface of their base class. */
    void ClientCode(AbstractClass *class_) { 
      // ...
      class_->TemplateMethod();
      // ...
    }
    
    int main() { 
      std::cout << "Same client code can work with different subclasses:\n";
      ConcreteClass1 *concreteClass1 = new ConcreteClass1;
      ClientCode(concreteClass1);
      std::cout << "\n";
      
      std::cout << "Same client code can work with different subclasses:\n";
      ConcreteClass2 *concreteClass2 = new ConcreteClass2;
      ClientCode(concreteClass2);
      
      delete concreteClass1;
      delete concreteClass2;
      
      return 0;
    }

output:

Same client code can work with different subclasses:
    AbstractClass says: I am doing the bulk of the work
    ConcreteClass1 says: Implemented Operation1
    AbstractClass says: But I let subclasses override some operations
    ConcreteClass1 says: Implemented Operation2
    AbstractClass says: But I am doing the bulk of the work anyway
    
    Same client code can work with different subclasses:
    AbstractClass says: I am doing the bulk of the work
    ConcreteClass2 says: Implemented Operation1
    AbstractClass says: But I let subclasses override some operations
    ConcreteClass2 says: Overridden Hook1
    ConcreteClass2 says: Implemented Operation2
    AbstractClass says: But I am doing the bulk of the work anyway

[20201203111443153.png_pic_center]: /images/20221120/afa2ba24c3364548a35488f91108530b.png
[Link 1]: https://blog.csdn.net/qq_36631379/article/details/109620798