模板方法

模板方法Template Method模式

在稳定的整体操作结构中，子步骤可以进行变化来满足需求

template_lin.cpp

 1 //程序库开发人员
 2 class Library{
 3 
 4 public:
 5     void Step1(){
 6         //...
 7     }
 8 
 9     void Step3(){
10         //...
11     }
12 
13     void Step5(){
14         //...
15     }
16 };

template1_app.cpp

//应用程序开发人员
class Application{
public:
    bool Step2(){
        //...
    }

    void Step4(){
        //...
    }
};

int main()
{
    Library lib();
    Application app();

    lib.Step1();

    if (app.Step2()){
        lib.Step3();
    }

    for (int i = 0; i < 4; i++){
        app.Step4();
    }

    lib.Step5();

}

这种方式为早绑定在Application去调用Library。

template2_lib.cpp

class Library{
public:
    //稳定 template method
    void Run(){
        
        Step1();

        if (Step2()) { //支持变化 ==> 虚函数的多态调用
            Step3(); 
        }

        for (int i = 0; i < 4; i++){
            Step4(); //支持变化 ==> 虚函数的多态调用
        }

        Step5();

    }
    virtual ~Library(){ }

protected:
    
    void Step1() { //稳定
        //.....
    }
    void Step3() {//稳定
        //.....
    }
    void Step5() { //稳定
        //.....
    }

    virtual bool Step2() = 0;//变化
    virtual void Step4() =0; //变化
};

template2_app.cpp

//应用程序开发人员
class Application : public Library {
protected:
    virtual bool Step2(){
        //... 子类重写实现
    }

    virtual void Step4() {
        //... 子类重写实现
    }
};




int main()
    {
        Library* pLib=new Application();
        lib->Run();

        delete pLib;
    }
}

该种为晚绑定，Library中通过虚函数的方式来调用子类中方法

Template method模式即在软件构建中，具有稳定的操作结构（即代码运行逻辑稳定）但子步骤是变化的，

该模式意为稳定操作结构在父类中实现，变化的步骤延迟（虚函数）到子类中。

上面代码中代码1即操作结构在main()函数中实现，以早绑定方式去调用库。

代码2即将操作结构在父类中实现，以虚函数Step2(),Step4()的方式在延迟在子类中实现，只需要将变化的步骤在子类中重定义即可。

完全稳定和完全变化的结构都不适用设计模式，设计模式为在软件设计时分离稳定和变化的部分，来实现代码复用。

拓宽一下思路：如果这个流程中的各个步骤不是固定的，该如何设计呢？其实，应用层可以自己动态配置调用步骤。即可调用已有的接口满足小白用户需求，也可构建复杂流程完成专家级需求

run方法中的流程可以任意改变，只需通过动态配置即可，但流程中的各个变化任然可以通过子类的继承来实现多态

其实真正如的工业级代码非常复杂：模板方法模式中的稳定部分run不在模板类中，而在另外一个类中，这个流程是由若干类相互协作共同完成。