组件协作模式--Tmplate Method模板方法

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/w_jingjing0428/article/details/52781371

对于一个编程才刚入门的人来说，现在来讲设计模式就是赶鸭子上架的感觉，我好像Java代码只是比小白好了那么一点点，实在惭愧。

大家都知道设计模式有很多种，由此分类也是有很多标准，这里是按照从封装变化角度对模式进行分类，特此说明一下。另外，对于刚刚接触过设计模式的人，常常会陷入泥潭，就是处处都会想着是不是可以来个模式，然而这就容易导致过度设计，又会陷入另外一个泥潭。所以设计模式就像流传在世的武功秘籍，练得好，可以增加功力，练得不好，容易走火入魔。所以此时重构又是另外一项很重要的事。下面列举一下重构的关键技法：

• 静态 –> 动态
• 早绑定 –>晚绑定
• 继承 –> 组合
• 编译时依赖 –>运行时依赖
• 紧耦合 –>松耦合

这篇文章主要介绍Tmplate Method模板方法。

为啥会出现这个方法呢？从它设计的目的来看：在软件构建的过程中，对于某一项任务，它常常有稳定的整体操作结构，但各个子步骤却有很多改变的需求，或者由于固有的原因（比如框架和应用之间的关系）而无法和任务的整体结构同时实现。意思就是说，其实有很多的任务都是一样的，而子步骤就可能会有不同的实现，这时为了应对各个子步骤的变化，所以由此模板方法就出现了。

比如程序库开发人员把库的框架设计好之后，应用层的开发人员通常会去实现每个方法，然后去组织程序的主流程，以上结构化软件设计的一般流程，而对于面向对象软件设计，程序库开发人员通常是把框架设计好，并对主程序流程也设计好，让应用开发人员去实现各个功能，这样如果有另外的功能加进去，或者别的开发人员也想用这个库，就只需要关注单独的功能任务的实现了。下面用代码来演示一遍：

//程序库开发人员
class Library {

    //稳定
    public void step1() {
        //...
    }

    //稳定
    public void step3() {
        //...
    }

    //稳定
    public void step5() {
        //...
    }

}

把程序库写好之后，应用层的程序员就要这样写，

//应用程序开发人员
class Application {

    //变化
    public boolean step2() {
        //...
        return true;
    }

    //变化
    public void step4() {
        //...
    }

    //稳定
    public static void main(String args[]) {

        Library lib = new Library();

        Application app = new Application();

        lib.step1();

        if (app.step2()) {
            lib.step3();
        }

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

        lib.step5();
    }

}

当main方法中的主流程呈现稳定态的时候，这种写法显然是不利于不同功能的实现的，而且创建的类即涉及到子类又涉及到抽象类，看着不好。那我们来看看另外一种写法，库设计人员就提前把主流程写好，程序员就只需要实现自己想要的个性功能。

//程序库开发人员
abstract class Library {
    public void run() {//稳定 template method

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

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

        step5();
    }


    protected void step1() {//稳定
        //...
    }

    protected void step3() {//稳定
        //...
    }

    protected void step5() {//稳定
        //...
    }

    abstract boolean step2();//变化

    abstract void step4();//变化
}

而应用开发人员就做的很简单：

//应用程序开发人员
class Application extends Library {

    @Override
    protected boolean step2() {
        //... 子类重写实现
        return true;
    }

    @Override
    protected void step4() {
        //... 子类重写实现
    }

    public static void main(String args[]) {

        Library lib = new Application();
        lib.Run();

    }
}

只需要调用run方法就能完成和第一种写法一样的功能，而且更加的好。为什么好呢？第一，早绑定和晚绑定的区别，第一种方法两个类型在编译和运行的时候都是一样的，这样在编译的时候，他们俩的行为就已经绑定在一起了，而第二种写法lib在编译的时候是属于Library类型，然而在运行的时候呈现了子类的Application特征，所以他们俩的联系在运行的时候才确定，也就是晚绑定，也就是利用了java的多态性质，面试的时候我这样解释多态好像面试官不是特别满意的样子，不知道是不是我理解错了。
看到这，模板方法通俗来说就是你不调用我，我来调用你这种反向控制，其中利用了多态性，为很多应用程序框架提供了灵活的扩展点，是代码复用的基本实现结构。

一点愚见。