设计模式——09 模板方法模式

最新推荐文章于 2025-02-04 17:37:52 发布

Vander1991

最新推荐文章于 2025-02-04 17:37:52 发布

阅读量241

点赞数

CC 4.0 BY-SA版权

分类专栏：计算机基础

本文链接：https://blog.youkuaiyun.com/Vander1991/article/details/83860467

计算机基础专栏收录该内容

11 篇文章

订阅专栏

本文深入解析模板方法模式，展示如何在算法中定义骨架并延迟步骤到子类，以实现代码复用和算法结构的保护。通过咖啡和奶茶制作流程的例子，阐述了模式的实现和好处，包括抽象父类的作用、钩子方法的使用，以及好莱坞原则的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

09 Template Method Pattern（模板方法模式）

前言：封装步骤的算法。

Vander作为老板，凡是亲力亲为，他新开了家咖啡店，这是他招牌咖啡卡布奇诺的冲泡方法：

1、把水煮沸

2、用沸水冲泡咖啡

3、将咖啡倒入咖啡杯

4、加糖和奶

Vander发现白天喝咖啡的人实在是不多，白天的生意很差，白天大家都喜欢喝奶茶，特别是夏天到了，冰凉的奶茶更受欢迎，于是Vander开始研制它的柠檬奶茶。以下是柠檬奶茶的制作方法：

1、把水煮沸

2、用沸水泡茶叶

3、将茶倒入茶杯中

4、加柠檬和奶

Vander如行云流水般写完了这两个制作方法。

咖啡：

public class Coffee {

	void prepareRecipe() {
		boilWater();
		brewCoffeeGrinds();
		pourInCup();
		addSugarAndMilk();
	}

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

	public void brewCoffeeGrinds() {
		System.out.println("Dripping Coffee throught filter");
	}

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

	public void addSugarAndMilk() {
		System.out.println("Adding sugar and milk");
	}
	
}

奶茶：

public class MilkTea {

	void prepareRecipe() {
		boilWater();
		steepTeaBag();
		pourInCup();
		addTeaAndMilk();
	}

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

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

	public void steepTeaBag() {
		System.out.println("Steeping the tea");
	}

	public void addTeaAndMilk() {
		System.out.println("Adding tea and milk");
	}
	
}

他自认为写得很漂亮，请来了Panda大师一起来鉴赏，Panda大师一看，这个实现有太多冗余代码了，首先奶茶跟咖啡制作流程既然是相似的，为什么不做成一个Beverage抽象类，让它们来继承呢，在抽象类中将prepareRecipe方法固定下来，这样后面的制作的饮料都要遵循这个流程了，接下来煮水和将饮料倒入杯中实际上也是一样的，也能在抽象的父类Beverage中实现，steep（浸泡）和brew（冲泡）实际上也没多大区别，所以给个新名字brew，最后加入糖和奶跟加入柠檬和奶，也是类似的，也给个新名字addCondiments。改造完之后类图如下：

Vander仔细琢磨了Panda大师的做法，发现Panda大师实际上先做了泛化（将实现泛化成抽象通用），接着再将一些具体的步骤交给子类来完成。Vander想了想其实prepareRecipe完全可以定义成final。这样就把这个传统的做法定义下来，不允许子类擅自修改流程。

Panda大师一看，不错，你终于学到精髓了，实际上我们刚刚的做法就是用了模板方法模式。Panda来总结一下模板方法模式的好处：

1、抽象父类中定义了算法（也就是饮料制作流程），保护了算法。

2、对于子类来说，抽象父类的存在将代码的复用最大化。

3、算法只存在于一个地方，方便修改。

4、模板方法提供了一个框架，可以让其他饮料插进来，新的饮料只要实现自己的方法就行了。

5、抽象父类专注于方法本身，而由子类提供完整的实现。

Panda大师指导改造后，代码成这样：

Beverage：

public abstract class Beverage {

	public final void prepareRecipe() {
		boilWater();
		brew();
		pourInCup();
		addCondiments();
	}
	
	public void boilWater() {
		System.out.println("Boiling water");
	}
	
	abstract void brew();
	
	public void pourInCup() {
		System.out.println("Pouring into cup");
	}
	
	abstract void addCondiments();
	
}

coffee：

public class Coffee extends Beverage {

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

	@Override
	void addCondiments() {
		System.out.println("Adding sugar and milk");
	}
	
}

Milktea:

public class Milktea extends Beverage {

	public void brew() {
		System.out.println("Steeping the tea");
	}

	public void addCondiments() {
		System.out.println("Adding tea and milk");
	}
	
}

说了那么多，模板方法模式具体是什么呢？

模板方法模式:在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

实际上这个模式是用来创建一个算法的模板。什么是模板呢，实际上模板就是一个方法，更具体地说，这个方法将算法定义成一组步骤，其中任何步骤都可以是抽象的，由子类负责实现。这可以确保算法的结构保持不变，同时由子类提供部分实现。

下面是模板方法模式常用的套路：

这里需要说明的是，抽象类中有个钩子方法，这个钩子方法是在抽象类中提供了一个简单的实现，子类可以选择去覆盖它重新实现，也可以使用父类的实现。

有了Panda大师度身定制咖啡和奶茶之后，添加其他饮料更加方便了，很快就加入了蔬菜汁等饮料。但是有些客人不喜欢喝带奶的卡布奇诺，他喜欢喝纯咖啡。Vander想了想，能不能让客户告诉我要不要加奶和糖，我在制作的时候就可以按照客户的请求来完成了，实际上这是任何一个奶茶店和咖啡店都需要有的基本功能。Vander是这么改造的：

饮料父类：

public abstract class Beverage {

	public final void prepareRecipe() {
		boilWater();
		brew();
		pourInCup();
		if(customCondiments()) {
			addCondiments();
		}
	}
	
	public void boilWater() {
		System.out.println("Boiling water");
	}
	
	abstract void brew();
	
	public void pourInCup() {
		System.out.println("Pouring into cup");
	}
	
	abstract void addCondiments();
	
	public boolean customCondiments() {
		return true;
	}
	
}

咖啡类：

public class Coffee extends Beverage {

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

	@Override
	void addCondiments() {
		System.out.println("Adding sugar and milk");
	}
	
	public boolean customCondiments() {
		String answer = getUserInput();
		if(answer.toLowerCase().startsWith("y")) {
			return true;
		} else {
			return false;
		}
	}
	
	private String getUserInput() {
		String answer = null;
		System.out.println("would you like some milk and sugar with your coffee (y/n)? ");
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
		try {
			answer = bufferedReader.readLine();
		} catch (IOException e) {
			System.err.println("IO error trying to read your answer");
		}
		if(answer == null) {
			return "no";
		}
		return answer;
	}
	
}

奶茶类：

public class MilkTea extends Beverage {

	public void brew() {
		System.out.println("Steeping the tea");
	}

	public void addCondiments() {
		System.out.println("Adding sugar and milk");
	}
	
	public boolean customCondiments() {
		String answer = getUserInput();
		if(answer.toLowerCase().startsWith("y")) {
			return true;
		} else {
			return false;
		}
	}
	
	private String getUserInput() {
		String answer = null;
		System.out.println("would you like some milk and sugar with your tea (y/n)? ");
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
		try {
			answer = bufferedReader.readLine();
		} catch (IOException e) {
			System.err.println("IO error trying to read your answer");
		}
		if(answer == null) {
			return "no";
		}
		return answer;
	}
	
}

实现的效果：

下面再说明一下钩子算法的目的：（实际上就是为了让子类有能力为其抽象类作一些决定）

1、让子类实现算法中的可选部分

2、能够让子类有机会对模板方法中某些即将发生的步骤作出反应（如在上面的咖啡类中，完全可以让父类来询问是否加入佐料，而子类再进行加入佐料后的一些附加操作）。

还要注意的是，在写模板方法时，不要将算法的步骤切割得太细（子类要实现太多操作），也不要步骤太少（会没有弹性），所以要看情况折衷。步骤可选的时候就使用钩子方法。

模板方法模式跟一个设计原则很吻合，这个手机原则就是好莱坞原则——别调用（打电话给）我们，我们会调用（打电话给）你。好莱坞原则可以防止“依赖腐败”，什么是依赖腐败呢，当高层组件依赖底层组件，而底层组件又依赖高层组件，而高层组件又依赖边侧组件，边侧组件还依赖于底层组件的时候依赖腐败就发生了，这种情况很难搞清楚系统是如何设计的。我们允许底层组件将自己挂钩到系统上，但是高层组件会决定什么时候和如何使用这些组件。换句话说：高层组件对待底层组建的方式就是“别调用我们，我们会调用你”。实际上不只是模板方法模式，工厂模式和观察者模式也采用了好莱坞原则。

好莱坞原则 VS 依赖倒置原则

比较

原则

好莱坞原则

依赖倒置原则

相同点

目的都是为了解耦

不同点

用在创建框架或组件上的一种技巧，让底层组件能被挂钩进来参与计算，又不会让高层组件依赖底层组件。

告诉我们尽量避免使用抽象类，更多地使用抽象。更侧重如何在设计中避免依赖

先对比一下策略模式和模板方法模式：

策略模式：将算法定义成对象，其他对象通过委托的方式来让这些算法用起来。

模板方法模式：定义算法的一个大纲，算法中的个别步骤可以有不同的实现细节，会重复使用的代码可以放进超类中，好让所有的子类共享。

模板方法模式 VS 策略模式 VS 工厂方法模式

模式	叙述
模板方法	子类决定如何实现算法中的步骤
策略	封装可互换的行为，然后使用委托来决定要采用哪一个行为
工厂方法	由子类决定实例化哪个具体类

下面我们要进入Java中的模板方法，模板方法并非刚刚举的例子那样明显，有些隐藏得颇深，让我们来细细挖掘。

Java数组类的设计者给出了一个排序的算法，但是排序的方法中compareTo方法却是需要我们自身实现的，因为设计者无法知道你想按照什么东西来进行排序，你必须告诉这个排序算法你依照什么来进行排序的。

接下来看看Sun的源码：

Comparable接口：

public interface Comparable<T> {   
	   public int compareTo(T o);
}

Arrays的相关函数：

    public static void sort(Object[] a) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a);
        else
            ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
    }

    /** To be removed in a future release. */
    private static void legacyMergeSort(Object[] a) {
        Object[] aux = a.clone();
        mergeSort(aux, a, 0, a.length, 0);
    }    private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low,
                                  int high,
                                  int off) {
        int length = high - low;

        // Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low &&
                         ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

        // Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off);
        mergeSort(dest, src, mid, high, -off);

        // If list is already sorted, just copy from src to dest.  This is an
        // optimization that results in faster sorts for nearly ordered lists.
        if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
            System.arraycopy(src, low, dest, destLow, length);
            return;
        }

        // Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }

    /**
     * Swaps x[a] with x[b].
     */
    private static void swap(Object[] x, int a, int b) {
        Object t = x[a];
        x[a] = x[b];
        x[b] = t;
    }

具体的排序细节见博客中数据结构的MergeSort，这里关注的是Arrays的Sort方法会调用数组的compareTo来进行比较，比较之后再进行位置的对调，这实际上就是让子类数组来实现具体的算法细节（即比较），而父类数组完成算法的步骤（即排序）。

另外，sort()模板方法实现不使用继承，sort方法被定义成一个静态的方法，在运行时和Comparable组合，如果类不实现Comparable接口的话就会导致sort方法中类型转换失败。

下面再看一个模板方法的实例JFrame，里面的paint方法是一个钩子方法，默认情况下是不做事情的，要是你继承了JFrame并且实现了paint方法，它就会进行相应的操作。

MyFrame类：

public class MyFrame extends JFrame {

	public MyFrame(String title) {
		super(title);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		this.setSize(300, 300);
		this.setVisible(true);
	}
	
	public void paint(Graphics graphics) {
		super.paint(graphics);
		String msg = "09-Template-Method-Pattern";
		graphics.drawString(msg, 80, 150);
	}
	
}

Main：

public class Main {

	public static void main(String args[]) {
		MyFrame frame = new MyFrame("Design Pattern");
	}

}

我们查看堆栈信息发现，paint方法也相当于作为一个步骤被其它算法调用。

模板方法定义了算法的步骤，把这些步骤实现延迟到了子类，它是一种代码复用的技巧。

好莱坞原则告诉我们，将决策权放在高层模块中，以便决定如何以及何时调用低层模块。

策略模式和模板方法模式都封装算法，一个用组合，一个用继承。工厂方法是模板方法的一种特殊版本。

最后又到了喜闻乐见的总结部分，我们又来总结我们现在现有的设计模式武器。

面向对象基础

抽象、封装、多态、继承

八大设计原则

设计原则一：封装变化

设计原则二：针对接口编程，不针对实现编程。

设计原则三：多用组合，少用继承。

设计原则四：为交互对象之间的松耦合设计而努力

设计原则五：对扩展开放，对修改关闭

设计原则六：依赖抽象，不要依赖于具体的类

设计原则七：只和你的密友谈话

设计原则八：别找我，我有需要会找你

模式

模板方法模式：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

最后献上此次设计所涉及到的源码，有需要的小伙伴可以下载来运行一下，首先先自己进行设计，然后再参考，这样才能加深外观模式的理解。