设计模式之模板方法

---

前言

这篇文章介绍一下设计模式中的一种模式，模板方法。为什么要先介绍模板方法呢？而不是单例模式或者什么工厂方法呢？因为模板方法更能体现出设计模式的精髓：先满足设计原则，再迭代出设计模式。如果还不了解的朋友，可以先看上一章基础理论。

---

以下是本篇文章正文内容

一、模板方法的定义

模板方法定义了一个操作中的算法骨架，而将一些步骤延迟到子类中实现。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。它是属于一种行为型的设计模式。

二、模板方法的使用

1.背景

在某个品牌的动物园，有一套固定的表演流程，但其中有若干个表演子流程可以创新替换，以尝试迭代更新表演流程。

2.分析

稳定点：动物园内有一套固定的表演流程。
变化点：每个表演子流程可以迭代更新。
套用模板方法解决这个问题的时候，固定的算法骨架就是这个一整套表演流程，延迟到子类中实现的就是这些具体表演流程的算法。

3.程序

程序1：一个不怎么样的代码

class zooShow
{
public:
    zooShow(int type)
    {
        _type = type;
    }
    void show()
    {
        if(show0())
            play_game();
        show1();
        show2();
    }
private:
    bool show0()
    {
        switch (_type)
        {
        case 1:
            cout << "show0" << endl;
            break;

        case 2:
            cout << "show00" << endl;
            break;
        
        default:
            break;
        }
        return true;
    }
    void play_game()
    {
        std::cout << "play game" << std::endl;
    }
    void show1()
    {
        switch (_type)
        {
        case 1:
            cout << "show1" << endl;
            break;

        case 2:
            cout << "show11" << endl;
            break;
        
        default:
            break;
        }
    }
    void show2()
    {
        switch (_type)
        {
        case 1:
            cout << "show2" << endl;
            break;

        case 2:
            cout << "show22" << endl;
            break;
        
        default:
            break;
        }
    }

    int _type;
};

int main()
{
    zooShow *z = new zooShow(1);
    z->show();
    return 1;
}

为什么称上面的代码不怎么样呢？

1. 不符合开闭原则，每次有新的表演流程的时候都需要改zooShow这个类，久而久之这个类会变得冗余不堪。
2. 不符合单一职责，一个类有不止一个引起它变化的原因（比如_type）。

程序2：稍微好一些的代码

class zooShow
{
public:
    void show()
    {
        if(show0())
            play_game();
        show1();
        show2();
    }
private:
    virtual bool show0()
    {
        cout << "show0" << endl;
        return true;
    }
    void play_game()
    {
        std::cout << "play game" << std::endl;
    }
    virtual void show1()
    {
        cout << "show1" << endl;
    }
    virtual void show2()
    {
        cout << "show2" << endl;
    }

};

class zooShowEx1:public zooShow
{
private:
    bool show0() override
    {
        cout << "zooShowEx1 show0" << endl;
        return true;
    }
    void show1() override
    {
         cout << "zooShowEx1 show1" << endl;
    }
};

class zooShowEx2:public zooShow
{
private:
    bool show0() override
    {
        cout << "zooShowEx2 show0" << endl;
        return true;
    }
    void show2() override
    {
         cout << "zooShowEx2 show2" << endl;
    }
};

int main()
{
    zooShow *z = new zooShowEx2();
    z->show();
    return 1;
}

为什么称上面的代码好一些呢？

1. 符合开闭原则，把zooShow声明为基类，新的变化只要继承这个基类并覆盖所需要修改的虚函数即可，不需要去修改该基类，符合对扩展开放，对修改关闭的原则。
2. 符合单一原则，基类zooShow唯一变化的原因就是主要骨架show()的变化。
3. 符合里式替换的原则，每个子类都可以替换父类。
4. 符合接口隔离原则，通过public和private的限定词，做到了只对上层应用开放了show接口，屏蔽了上层应用不需要关心的细节。
5. 很好的找到了稳定点（整体流程）和变化点（表演子流程）。

总结

写出良好的代码或者怎么学习设计模式无非就是两点：

1. 先写出满足设计原则的代码，往后再迭代出设计模式会变得简单些。
2. 找出问题的稳定点和变化点。