二哈谈设计模式之模板方法模式

模板方法模式

---

---

前言

• 介绍∶
  模板方法模式是编程中经常用得到模式。它定义了一个操作中的算法
  骨架，将某些步骤延迟到子类中实现。这样，新的子类可以在不改变一个算法结构的前提下重新定义该算法的某些特定步骤。
• 核心:
  处理某个流程的代码已经都具备，但是其中某个节点的代码暂时不能
  确定。因此，我们采用工厂方法模式，将这个节点的代码实现转移给子类完成。
  即∶处理步骤父类中定义好，具体实现延迟到子类中定义

---

一、具体实现

1.抽象模板

package templateMethod;

/**
 * 将数组排序
 */
abstract class AbstractSort {

    //具体方法
    private void start(){
        System.out.println("从小到大的排序结果为：");
    }

    //钩子方法
    protected abstract void sort (int [] array);

    //模板方法
    public  final void showResult(int [] array){
        this.sort(array);
        start();
        for (int i = 0; i < array.length; i++) {
            int i1 = array[i];
            System.out.print(i1+" ");
        }
    }

}

2.子类继承

package templateMethod;

public class ConcreteSort extends AbstractSort {
    @Override
    protected void sort(int[] array) {
        selectSort(array);
    }

    private void selectSort(int [] array) {
        int temp;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length-1; j++) {
                if (array[j+1] < array[j]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }
}

3.测试类

package templateMethod;

public class Client {
    public static void main(String[] args) {
        int[] array ={10,12,32,1,9,5,7,0,3,4};
        AbstractSort s = new ConcreteSort();
        s.showResult(array);
    }
}

结果：

二、三类模板方式

模板方法实际只是用了Java的继承机制，其中，AbstractClass叫做抽象模板，它的方法分为三类：

• 基本方法：由子类实现的方法，并且在模板方法中被调用。
• 模板方法：模板方法可以有一个或几个，是一个骨架，实现对基本方法的调度，完成固定的逻辑。为了防止恶意操作，一般模板方法都加上了final关键字，不允许被重写。
• 钩子方法：由抽象类声明并加以实现。但是子类可以去拓展，子类可以通过扩展钩子方法来影响模板方法的逻辑。

---

三、应用场景

• 数据库访问的封装. Junit单元测试
• servlet中关于doGet/doPost方法调用. Hibernate中模板程序
• spring中JDBCTemplate、HibernateTemplate等。
• Thread类的run()方法和start()方法

总结

优点：

• 容易扩展：抽象类的模板方法是不易发生改变的部分，而抽象方法是容易发生变化的部分，因此通过增加实现类，一般可以很容易地实现功能的扩展，符合开闭原则。
• 便于维护：对于模板方法模式来说，正是由于它们的主要逻辑相同，才使用了模板方法，假如不使用，则维护起来很不方便。
• 比较灵活：因为有钩子方法，因此，子类的实现也可以影响父类中主逻辑的运行。但是，在灵活的同时，由于子类影响到了父类，违反了里氏替换原则，也会给程序带来风险。这就是对抽象类的设计有了更高的要求。