Java 设计模式13——模板方法模式

发表于 | 分类于 ，

模板定义

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

通常这个抽象类定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

模式示例

下面以一个奶茶店为例，咖啡馆主要生成两种饮品：咖啡和茶。准备的的大体流程相似：烧水，煮，导入杯中给客户，还可以视客户需要加一些额外的调剂品，如牛奶和糖。上面的过程可以抽象出如下过程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

public abstract class CaffeineBeverage {

    private boolean isNeedToAddCondiments = true;

    /**
     * 通用算法
     * 大体的制作流程
     */
    public final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    /**
     * 不同的部分，由子类实现
     */
    protected abstract void brew();

    /**
     * 不同的部分，由子类实现
     */
    protected abstract void addCondiments();

    private void boilWater() {
        System.out.println("Boiling water");
    }

    private void pourInCup() {
        System.out.println("Pouring into cup");
    }

    /**
     * 询问是否需要额外添加品
     * @return true if needed
     */
    public boolean customerWantsCondiments() {
        return isNeedToAddCondiments;
    }

    /**
     * 设置是否需要额外添加品
     */
    public void setCustomerWantsCondiments(boolean needToAddCondiment) {
        isNeedToAddCondiments = needToAddCondiment;
    }
}

Coffee的具体流程

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Coffee extends CaffeineBeverage {

    @Override
    protected void brew() {
        System.out.println("Dripping Coffee through filter");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding Sugar and Milk");
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Tea extends CaffeineBeverage {

    @Override
    protected void brew() {
        System.out.println("Steeping the tea");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding Lemon");
    }

}

奶茶店实现如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TeaHouseClient {
   public static void main(String[] args) {
 
      Tea tea = new Tea();
      Coffee coffee = new Coffee();
 
      System.out.println("\nMaking tea...");
      tea.prepareRecipe();
 
      System.out.println("\nMaking coffee...");
      coffee.setCustomerWantsCondiments(false);
      coffee.prepareRecipe();

   }
}

输出结果如下

1
2
3
4
5
6
7
8
9
10
Making tea...
Boiling water
Steeping the tea
Pouring into cup
Adding Lemon

Making coffee...
Boiling water
Dripping Coffee through filter
Pouring into cup

上面示例中，prepareRecipe()就是抽象出来的通用算法，不管什么新的品类，都要经过这个操作，需要写在模板类中。像addCondiments()和brew()等抽象方法他们视不同的品类而不同，因而交给子类来实现。

模式总结

开发过程中，一些流程化的操作中，通常会有通用的流程，为了避免在每一次实现中都进行一次编码，我们可以把通用的不同抽象出来，定义成模板，不同的部分定义成抽象方法，供子类去实现，这就是模板方法模式。Android开发中的经常封装的BaseActivity通常都会应用这种方式。

优缺点

  • 优点
    1. 封装不变部分，扩展可变部分；
    2. 提取公共代码，便于维护；
    3. 行为由父类控制，子类实现。
  • 缺点
    • 每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

注意事项

  1. 为防止恶意操作，一般模板方法都加上 final 关键词。
  2. 通用操作在抽象类实现，其他步骤在子类实现。

使用场景

  1. 有多个子类共有的方法，且逻辑相同。
  2. 重要的、复杂的方法，可以考虑作为模板方法。