设计模式：模板方法模式(template method)---将具体处理交给子类

Love The Way You Lie 2022-09-05 01:41 185阅读 0赞

# 模板模式 #

## 什么是模板 ##

模板的原意是指带有镂空文件的塑料板。只要用笔在模板的镂空处进行临摹，即使是书写也能写出整齐的文字。只要看到这些镂空的动，我们就可以知道能写出哪些文字，但是具体写出的文件是什么感觉则依赖于使用的笔。如果是签字笔就写出签字似的文件，如果是铅笔就写出铅笔字，如果是彩色笔就写出彩色字。但是无论是什么笔，文字的形状都会与模板上镂空的形状一致。

## 什么是模板方法模式 ##

**模板方法模式**是带有模板功能的模式，组成模板的方法被定义在父类中。由于这些方法是抽象方法，所以只查看父类的代码是无法知道这些方法最终会进行何种具体处理的，唯一能知道的就是父类是如何调用这些方法的。

实现上面这些抽象方法的是子类。在子类中实现了抽象方法也就决定了具体的处理。也就是说，只要在不同的子类中实现不同的处理，当父类的目标方法被调用时程序行为也会不同。但是，不论子类中的具体实现如何，处理的流程都会按照父类中所定义的那样进行。

向这样在**父类中定义处理流程的框架，在子类中实现具体的处理**的模式就叫做**模板方法模式**

# 编程技巧：如果不想声明父类的实例，只想生成子类的实例 #

只需要将父类的构造函数给予protected权限（父类的析构函数必须是public）

这时如果硬要生成实例，将会报错：‘AbstractDisplay::AbstractDisplay()’是保护的

class AbstractClass {
        
    public:
        virtual void TemplateMethod() {
        
            PrimitiveOperation1();
            PrimitiveOperation2();
        }
    
        virtual ~AbstractClass() {
         }
    protected:
        virtual void PrimitiveOperation1() = 0;
        virtual void PrimitiveOperation2() = 0;
        AbstractClass() {
         }
    };

# 实现 #

## 示例1 ##

#include <iostream>
    using namespace std;
    
    class AbstractClass {
        
    public:
        virtual void TemplateMethod() {
        
            PrimitiveOperation1();
            PrimitiveOperation2();
        }
    
        virtual ~AbstractClass() {
         }
    protected:
        virtual void PrimitiveOperation1() = 0;
        virtual void PrimitiveOperation2() = 0;
        AbstractClass() {
         }
    };
    
    class ConcreteClass1 :public AbstractClass {
        
    public:
        void PrimitiveOperation1() {
        
            cout << "ConcreteClass1::PrimitiveOperation1" << endl;
        }
    
        void PrimitiveOperation2() {
        
            cout << "ConcreteClass1::PrimitiveOperation2" << endl;
        }
    };
    
    class ConcreteClass2 :public AbstractClass {
        
    public:
        void PrimitiveOperation1() {
        
            cout << "ConcreteClass2::PrimitiveOperation1" << endl;
        }
    
        void PrimitiveOperation2() {
        
            cout << "ConcreteClass2::PrimitiveOperation2" << endl;
        }
    };
    
    
    
    int main(int argc, char* argv[]) {
        
        AbstractClass *p1 = new ConcreteClass1();
        AbstractClass *p2 = new ConcreteClass2();
        p1->TemplateMethod();
        p2->TemplateMethod();
    
        delete p1;
        delete p2;
    
        return 0;
    }

## 实现2： ##

1.  在AbstractClass类中定义了display方法，而且在该方法中依次调用了open、print、close这三个方法。虽然这三个方法已经在AbstractClass中声明了，但都是没有实体的程序方法。这里，调用抽象方法的**display方法就是模板方法**
2.  而实际实现open、print、close这三个抽象方法的是AbstractClass的子类。
3.  也就是说具体的open、print、close的实际处理被交给了AbstractClass的子类

![在这里插入图片描述][8a22413604b54a4d97fa82b14ef89b63.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

#include <iostream>
    using namespace std;
    
    class AbstractDisplay {
        
    public:
        virtual void display() {
        
            open();
            for(int i = 0; i < 5; i++){
        
                print();
            }
            close();
        }
    
        virtual ~AbstractDisplay() {
         }
    protected:
        virtual void open() = 0;
        virtual void print() = 0;
        virtual void close() = 0;
        AbstractDisplay() {
         }
    };
    
    class CharDisplay :public AbstractDisplay {
        
    public:
        void open() {
        
            cout << "ConcreteClass1::PrimitiveOperation1" << endl;
        }
    
        void print() {
        
            cout << "ConcreteClass1::PrimitiveOperation1" << endl;
        }
    
        void close() {
        
            cout << "ConcreteClass1::PrimitiveOperation1" << endl;
        }
    };
    
    class StringDisplay :public AbstractDisplay {
        
    public:
        void open() {
        
            cout << "ConcreteClass2::PrimitiveOperation2" << endl;
        }
    
        void print() {
        
            cout << "ConcreteClass2::PrimitiveOperation2" << endl;
        }
    
        void close() {
        
            cout << "ConcreteClass2::PrimitiveOperation2" << endl;
        }
    };
    
    
    
    int main(int argc, char* argv[]) {
        
        AbstractDisplay *p1 = new CharDisplay();
        AbstractDisplay *p2 = new StringDisplay();
        p1->display();
        p2->display();
        
        
    
        delete p1;
        delete p2;
    
        return 0;
    }

# 总结 #

## 登场角色 ##

在模板方法模式中有如下登场角色：

*  `AbstractClass`(抽象类)：
    
     *  AbstractClass角色不仅负责实现模板方法，还负责声明在模板方法中所使用的抽象方法。
     *  这些抽象方法由子类ConcreteClass角色实现
 *  `ConcreteClass`(具体类)：
    
     *  负责实现AbstractClass角色中定义的抽象方法。
     *  这里实现的方法将会在AbstractClass角色的目标方法中被调用

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

## 优点 ##

### 可以使逻辑处理通用化 ###

由于在父类的模板方法中编写了算法，因此无需在每个子类中再编写算法

### 父类和子类之间的协作 ###

在**模板方法模式**中，父类和子类是紧密联系、共同工作的。因此，在子类中实现父类中声明的抽象方法时，必须要理解这些抽象方法被调用的实际。在看不到父类源代码的情况下，想要编写出子类是非常困难的

### 父类和子类的一致性 ###

在测试程序中，可以看出：

AbstractDisplay *p1 = new CharDisplay();
        AbstractDisplay *p2 = new StringDisplay();
        p1->display();
        p2->display();

不管是CharDisplay的实例还是StringDisplay的实例，都是先保存在AbstractDisplay 类型的变量中，然后再来调用display()方法的。

使用父类类型的变量保存子类实例的优点是：即使没有instranceof等指定子类的种类，程序也能正常工作。（这种原则叫做里氏替换）

## 相关设计模式 ##

*  Factory Method模式：
    
     *  工厂模式是将模板模式用于生成实例的一个典型例子
 *  Strategy模式
    
     *  在模板模式中，可以**使用继承改变程序的行为**。这是因为模板模式在父类中定义程序行为的框架，在子类中决定具体的处理
     *  **策略模式**可以**使用委托改变程序的行为**。与模板模式中改变部分程序行为不同的是，策略模式用于替换整个算法

## 延伸：类的层次和抽象类 ##

### 父类对子类的要求 ###

我们在理解类的层次时，通常是站在子类的角度进行思考的。也就是说，很容易着眼于以下几点：

*  在子类中可以使用父类中定义的方法
 *  可以通过在子类中增加方法以实现新的功能
 *  在子类中重写父类的方法可以改变程序的行为

现在，让我们站在父类的角度进行思考。在父类中，我们声明了抽象方法，而将该方法的实现交给了子类。换言之，就程序而言，声明抽象方法是希望达到如下目的：

*  期待子类实现抽象方法
 *  要求子类实现抽象方法

也就是说，子类具有实现父类中所声明的抽象方法的责任。因此，这种责任叫做“子类责任”

### 抽象类的意义 ###

对于抽象类，我们是无法生成其实例的。

由于在抽象方法中并没有编写具体的实现，因此我们无法知道在抽象方法中到底进行了什么样的处理。但是我们可以决定抽象方法的名字，然后通过调用使用了抽象方法的目标方法去编写处理。虽然具体的处理内容是由子类决定的，不过在**抽象类阶段确定处理的流程**非常重要

### 父类和子类之间的协作 ###

父类和子类的相互协作支撑齐了整个程序。虽然将更多的实现放在父类中会让子类变得更轻松，但是同时也降低了子类的灵活性；反之，如果父类中实现的方法过少，子类就会变得臃肿不堪，而且还会导致各子类间的代码出现重复。

在模板方法模式中，处理的流程被定义在父类中，而具体的处理交给了子类，但是对于“如何划分处理的级别，哪些处理需要由父类完成，哪些处理需要交给子类负责”并没有定式，这些需要开发人员自己决定。

## 总结 ##

本节中，我们学习了在父类中定义处理的流程，在子类中实现具体内容的目标方法模式。

另外，还分析了抽象类的意义和子类的责任

[8a22413604b54a4d97fa82b14ef89b63.png]: /images/20220829/825c96983761406692730aa93916bb7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20220829/44d35d0b15cf4fee87b5a7a966fdccdf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20220829/f25bc47889f548228f6a876ba3f4d57c.png