一杯下午茶引发的模板方法模式，给我一杯下午茶，我让你明白模板方法模式（Template Method Pattern）

简介

Define the skeleton of an algorithm in an operation,deferring some
steps to subclasses.Template Method lets subclasses redefine certain
steps of an algorithm without changing the algorithm’s structure.
定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
-----------------------------------------------------------------深入浅出的设计模式

• 模板方法模式（Template Method Pattern） 实际上是封装了一个固定流程，该流程由几个步骤组成，具体步骤可以由子类进行不同实现，从而让固定的流程产生不同的结果。

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

• 模板方法模式实际上是所有模式中最为常见的几个模式之一，而且很多人可能使用过模板方法模式而没有意识到自己已经使用了这个模式。模板方法模式是基于继承的代码复用的基本技术，模板方法模式的结构和用法也是面向对象设计的核心。模板方法的本质：抽象封装流程，具体进行实现

• 模版方法模式需要开发抽象类和具体子类的设计师之间的协作。

  1. 一个设计师负责给出一个算法的轮廓和骨架
  2. 另一些设计师则负责给出这个算法的各个逻辑步骤。
  3. 代表这些具体逻辑步骤的方法称做基本方法（primitive method）
  4. 将这些基本方法总汇起来的方法叫做模版方法（template method），这个设计模式的名字就是从此而来。

主要解决
当完成一个操作具有固定的流程时，由抽象固定流程步骤，具体步骤交给子类进行具体实现（固定的流程，不同的实现）。

优缺点

优点

• 封装不变，扩展可变：父类封装了具体流程以及实现部分不变行为，其它可变行为交由子类进行具体实现；
• 流程由父类控制，子类进行实现：框架流程由父类限定，子类无法更改；子类可以针对流程某些步骤进行具体实现；
• 提取公共代码，便于维护

缺点

• 抽象规定了行为，具体负责实现，与通常事物的行为相反，会带来理解上的困难（通俗地说，“父类调用了子类方法”）；
• 每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

使用场景

当我们要完成在某一细节层次一致的一个过程或一系列步骤，但其个别步骤在更详细的层次上的实现可能不同的时候，我们通常要考虑用模板方法模式解决。

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

注意事项： 为防止恶意操作，一般模板方法都加上 final 关键词。

模式讲解

首先来看下 模板方法模式 的通用 UML 类图：

模板方法模式
从 UML 类图中，我们可以看到，模板方法模式 主要包含两种角色：

抽象模板（AbstractClass）： 抽象模板类，定义了一套算法框架/流程；
具体实现（ConcreteClass）： 具体实现类，对算法框架/流程的某些步骤进行了实现；

当然这只是书面上的定义，用起来你会发现，为什么变得很复杂，好像更难了一样，你也有很多疑问？

• 在抽象类中只能定义抽象函数吗？
  不是！看使用场景第三条！
• 每一个抽象子类都要具体实现吗？
  语法上是的，但逻辑上，可以Do nothing
• 依据第一问，我能否对非抽象方法重写？
  当然，语法上可以，而且逻辑上也可以。

最后，设计模式给出的是一种设计框架，而不是条条框框，你需要用的是他真正优秀的地方！

开发实例

就一杯下午茶：

抽象类：

abstract class AbstractClass {
	protected void Boil_water() {
		System.out.println("SpecificMethod:烧水，倒一杯热水");
		/*
		 * 模板方法的抽象类中，也是可以定义具体方法的， 
		 * 一般子类中都具备或大部分中都具备时，放到抽象父类中。
		 */
	}
	// 需要子类必须实现的需要写成抽象类
	protected abstract void Abstract_step1();

	protected abstract void Abstract_step2();

	protected void Drink() {
		System.out.println("SpecificMethod:吹一吹再喝，别烫着！");
	}

	// 声明为final方法，避免子类覆写
	public final void After_Tea() {//来一杯下午茶吧
		this.Boil_water();
		this.Abstract_step1();
		this.Abstract_step2();
		this.Drink();
	}
}

我要喝咖啡

class Concrete_Cof extends AbstractClass {

	@Override
	// 具体实现，重写父类抽象方法
	protected void Abstract_step1() {
		System.out.println("把咖啡豆磨好，倒进杯子里");
	}

	@Override
	protected void Abstract_step2() {
		System.out.println("加入方糖和奶精");

	}

}

我要喝茶

class Concrete_Tea extends AbstractClass {

	@Override
	protected void Abstract_step1() {
		System.out.println("把茶饼分开，放进杯子里");
		
	}

	@Override
	protected void Abstract_step2() {
		//Do nothing 
		//可以写成这种什么都没有的，毕竟喝茶我什么都不加（手动狗头）
	}

}

我要喝奶茶

public class Concrete_MilkTea extends AbstractClass {

	protected void Boil_water() {
		System.out.println("煮一杯热牛奶");
	}
	@Override
	protected void Abstract_step1() {

		System.out.println("把茶饼分开，放进杯子里，过滤");

	}

	@Override
	protected void Abstract_step2() {
		System.out.println("加入方糖和香精");
	}

}

class Client {
	public static void main(String[] args) {
		AbstractClass abc = new Concrete_Cof();
		abc.After_Tea();
		System.out.println("----------Next day-------------");
		abc=new Concrete_Tea();
		abc.After_Tea();
		System.out.println("----------Next day-------------");
		abc=new Concrete_MilkTea();
		abc.After_Tea();
	}
}

运行结果：

码字这么卖力，麻烦点个赞，点个关注，谢谢。