java/android 设计模式学习笔记（22）---模板方法模式

最新推荐文章于 2025-04-05 22:22:50 发布

Shawn_Dut

最新推荐文章于 2025-04-05 22:22:50 发布

阅读量1.7k

点赞数 2

本文链接：https://blog.youkuaiyun.com/self_study/article/details/52662896

版权

Android 同时被 3 个专栏收录

92 篇文章

订阅专栏

Java

31 篇文章

订阅专栏

java

31 篇文章

订阅专栏

　　这篇博客我们来介绍一下模板方法模式（Template Method Pattern），也是行为型设计模式之一。在面向对象开发过程中，通常会遇到这样的一个问题，我们知道一个算法所需的关键步骤，并确定了这些步骤的执行顺序，但是，某些步骤的具体实现是未知的，或者说某些步骤的实现是会随着环境的变化而改变的，这时候我们就可以创建一个算法的模板，将算法定义成一组步骤，其中的任何步骤都可以是抽象的，由子类负责实现，这可以确保算法的结构保持不变，同时由子类提供部分实现。
　　转载请注明出处：http://blog.youkuaiyun.com/self_study/article/details/52662896。
　　PS：对技术感兴趣的同鞋加群544645972一起交流。

设计模式总目录

　　java/android 设计模式学习笔记目录

特点

　　定义一个操作中的算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。
　　模板方法模式的使用场景：

多个子类有共有的方法，并且逻辑基本相同时；
重要、复杂的算法，可以把核心算法设计成模板方法，周边相关细节功能则由各个子类实现；
重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数约束其行为。

UML类图

　　这里写图片描述
这里涉及到两个角色：

抽象模板（Abstract Template）角色有如下责任：
- 定义了一个或多个抽象操作，以便让子类实现，这些抽象操作叫做基本操作，它们是一个顶级逻辑的组成步骤。
- 定义并实现了一个模板方法，这个模板方法一般是一个具体方法，它给出了一个顶级逻辑的骨架，而逻辑的组成步骤在相应的抽象操作中，推迟到子类实现，顶级逻辑也有可能调用一些具体方法。
具体模板（Concrete Template）角色有如下责任：
- 实现父类所定义的一个或多个抽象方法，它们是一个顶级逻辑的组成步骤。
- 每一个抽象模板角色都可以有任意多个具体模板角色与之对应，而每一个具体模板角色都可以给出这些抽象方法（也就是顶级逻辑的组成步骤）的不同实现，从而使得顶级逻辑的实现各不相同。

我们可以写出模板方法模式的通用代码：
AbstractTemplate.class

public abstract class AbstractTemplate {
    /**
     * 模板方法
     */
    public void templateMethod(){
        //调用基本方法
        abstractMethod();
        hookMethod();
        concreteMethod();
    }
    /**
     * 基本方法的声明（由子类实现）
     */
    protected abstract void abstractMethod();
    /**
     * 基本方法(空方法)
     */
    protected void hookMethod(){
        System.out.print("AbstractTemplate hookMethod\n");
    }
    /**
     * 基本方法（已经实现）
     */
    private final void concreteMethod(){
        System.out.print("AbstractTemplate concreteMethod\n");
    }

    public static void main(String[] args) {
        AbstractTemplate templateA = new ConcreteTemplateA();
        templateA.templateMethod();

        AbstractTemplate templateB = new ConcreteTemplateB();
        templateB.templateMethod();
    }
}

ConcreteTemplateA.class

public class ConcreteTemplateA extends AbstractTemplate{
    @Override
    protected void abstractMethod() {
        System.out.print("ConcreteTemplateA abstractMethod\n");
    }
}

ConcreteTemplateB.class

public class ConcreteTemplateB extends AbstractTemplate{
    @Override
    protected void abstractMethod() {
        System.out.print("ConcreteTemplateB abstractMethod\n");
    }

    @Override
    protected void hookMethod() {
        System.out.print("ConcreteTemplateB hookMethod\n");
    }
}

最后运行的结果：

ConcreteTemplateA abstractMethod
AbstractTemplate hookMethod
AbstractTemplate concreteMethod
ConcreteTemplateB abstractMethod
ConcreteTemplateB hookMethod
AbstractTemplate concreteMethod

基类定义了一系列的步骤，然后子类按照这个步骤去实现，注意到两个方法，一个是 abstractMethod 和 hookMethod ，这两个方法的定位是不一样的， abstractMethod() 方法所代表的就是强制子类实现的剩余逻辑，而 hookMethod() 方法是可选择实现的逻辑，不是必须实现的。

示例与源码

　　Android 中使用模板方法模式最典型的例子就是 AsyncTask 和 Activity 的生命周期函数，这两个类基本都会有接触到，感兴趣的可以深入去了解。
　　我们这里以一个游戏的初始化为例子：
Game .class

/**
 * An abstract class that is common to several games in
 * which players play against the others, but only one is
 * playing at a given time.
 */
abstract class Game {
    /* Hook methods. Concrete implementation may differ in each subclass*/
    protected int playersCount;
    abstract void initializeGame();
    abstract void makePlay(int player);
    abstract boolean endOfGame();
    abstract void printWinner();

    /* A template method : */
    public final void playOneGame(int playersCount) {
        this.playersCount = playersCount;
        initializeGame();
        int j = 0;
        while (!endOfGame()) {
            makePlay(j);
            j = (j + 1) % playersCount;
        }
        printWinner();
    }
}

Monopoly.class

//大富翁
class Monopoly extends Game {

    /* Implementation of necessary concrete methods */
    void initializeGame() {
        System.out.print("Monopoly initializeGame\n");
    }
    void makePlay(int player) {
        return player > 4 ? 4 : palyer;
    }
    boolean endOfGame() {
        System.out.print("Monopoly endOfGame\n");
    }
    void printWinner() {
        System.out.print("Monopoly printWinner\n");
    }
    //....
}

Chess.class

//象棋
class Chess extends Game {

    /* Implementation of necessary concrete methods */
    void initializeGame() {
        System.out.print("Chess initializeGame\n");
    }
    void makePlay(int player) {
        return 2;
    }
    boolean endOfGame() {
        System.out.print("Chess endOfGame\n");
    }
    void printWinner() {
        System.out.print("Chess printWinner\n");
    }
    //.....
}

根据游戏的不同，不同的方法会有不同的执行结果，但是每个游戏的执行步骤是一样的。

总结

　　模板方法模式用四个字概括就是：流程封装。也就是把某个固定的流程封装到一个 final 函数中，并且让子类能够定制这个流程中的某些或者所有步骤，这就要求父类提取公用的代码，提升代码的复用率，同时也带来了更好的可封装性。
　　模板方法模式的优点：

封装不变部分，扩展可变部分；
提取公共部分代码，便于维护。

缺点：模板方法会带来代码阅读的难度，加大理解的难度，而且由于父类将步骤固定，所以有时候会增加扩展的难度。

源码下载

　　https://github.com/zhaozepeng/Design-Patterns/tree/master/TemplatePattern

引用

http://blog.youkuaiyun.com/jason0539/article/details/45037535
https://en.wikipedia.org/wiki/Template_method_pattern
http://www.cnblogs.com/java-my-life/archive/2012/05/14/2495235.html