模板方法模式让子类在不改变算法整体结构的前提下定制特定步骤，例如咖啡制作，不同咖啡遵循相同流程但有独特定制，如拿铁加牛奶，美式不加，这确保了制作流程的一致性，同时满足了不同咖啡的个性化需求，体现了模板方法模式的核心思想。
定义
模板方法模式是一种行为设计模式，它在一个方法中定义了一个算法的骨架，允许子类在不改变算法结构的情况下，对算法的某些步骤中的内容进行定制。
举一个现实中的例子：假设有一家咖啡店，店中提供多种咖啡，比如拿铁、美式、卡布奇诺等，虽然这些咖啡的制作过程有所不同，但它们都遵循一个基本的制作流程：准备咖啡豆、研磨咖啡豆、冲泡咖啡、倒入杯子、加入配料（如牛奶、糖等）、完成制作。
在这个例子中，制作咖啡的流程就是一个模板方法，它定义了一个算法的骨架，不同的咖啡（拿铁、美式、卡布奇诺等）就是这个模板方法的具体实现，它们会在算法的某些步骤上进行定制，比如，拿铁咖啡在冲泡后会加入牛奶，而美式咖啡则不会；卡布奇诺咖啡可能会在冲泡前多加入一些研磨后的咖啡豆，以增强咖啡的口感。
通过这种方式，可以确保每一种咖啡的制作都遵循基本的流程，同时又可以根据具体咖啡的需求对流程中的某些步骤进行定制，这就是模板方法的核心思想。
代码案例
正例
下面是一个未使用模板方法的反例代码，在这个例子中，假设有一个咖啡制作系统，其中包含了制作不同种类咖啡的方法，但由于没有使用模板方法，这些方法之间会存在大量的重复代码。
先定义一个CoffeeMaker类，它包含了制作拿铁咖啡和美式咖啡的方法，如下代码：
public class CoffeeMaker {
// 制作拿铁咖啡
public void makeLatte() {
prepareCoffeeBeans();
grindCoffeeBeans();
brewCoffee();
pourIntoCup();
addMilk(); // 拿铁咖啡特有的步骤：加入牛奶
System.out.println("拿铁咖啡制作完成！");
}
// 制作美式咖啡
public void makeAmericanCoffee() {
prepareCoffeeBeans();
grindCoffeeBeans();
brewCoffee();
pourIntoCup();
// 美式咖啡不需要添加其他配料
System.out.println("美式咖啡制作完成！");
}
// 准备咖啡豆
private void prepareCoffeeBeans() {
System.out.println("准备咖啡豆...");
}
// 研磨咖啡豆
private void grindCoffeeBeans() {
System.out.println("研磨咖啡豆...");
}
// 冲泡咖啡
private void brewCoffee() {
System.out.println("冲泡咖啡...");
}
// 倒入杯子
private void pourIntoCup() {
System.out.println("倒入杯子...");
}
// 拿铁咖啡特有的步骤：加入牛奶
private void addMilk() {
System.out.println("加入牛奶...");
}
}
接下来，编写一个client类CoffeeShop，用于调用CoffeeMaker中的方法来制作咖啡，如下代码：
public class CoffeeShop {
public static void main(String[] args) {
CoffeeMaker coffeeMaker = new CoffeeMaker();
// 制作拿铁咖啡
coffeeMaker.makeLatte();
// 制作美式咖啡
coffeeMaker.makeAmericanCoffee();
}
}
运行CoffeeShop的main方法，输出将会是，如下代码：
准备咖啡豆...
研磨咖啡豆...
冲泡咖啡...
倒入杯子...
加入牛奶...
拿铁咖啡制作完成！
准备咖啡豆...
研磨咖啡豆...
冲泡咖啡...
倒入杯子...
美式咖啡制作完成！
从上面的代码中，可以看到makeLatte和makeAmericanCoffee方法中有很多重复的步骤，如准备咖啡豆、研磨咖啡豆、冲泡咖啡和倒入杯子，这就是没有使用模板方法所带来的问题，当需要修改这些公共步骤时，必须在每个方法中都进行修改，这增加了出错的可能性和维护的难度。
如果使用了模板方法，可以将这些公共步骤提取到一个模板方法中，然后让具体的咖啡类（如拿铁咖啡、美式咖啡）继承这个模板方法，并只重写它们特有的步骤，从而减少重复代码并提高系统的灵活性。
反例
下面是一个使用模板方法的正例代码，在这个例子中，定义一个咖啡制作的模板方法，并让具体的咖啡类（如拿铁咖啡、美式咖啡）继承并实现它们特有的步骤。
首先，定义一个抽象类AbstractCoffee，它包含了制作咖啡的模板方法以及一些公共步骤的实现，如下代码：
// 抽象咖啡类，定义制作咖啡的模板方法
abstract class AbstractCoffee {
// 模板方法，定义制作咖啡的算法骨架
public final void prepareCoffee() {
prepareCoffeeBeans();
grindCoffeeBeans();
brewCoffee();
pourIntoCup();
addIngredients(); // 由子类实现的具体步骤
System.out.println(getCoffeeName() + "制作完成！");
}
// 准备咖啡豆
public void prepareCoffeeBeans() {
System.out.println("准备咖啡豆...");
}
// 研磨咖啡豆
public void grindCoffeeBeans() {
System.out.println("研磨咖啡豆...");
}
// 冲泡咖啡，抽象方法，由子类实现
protected abstract void brewCoffee();
// 倒入杯子
public void pourIntoCup() {
System.out.println("倒入杯子...");
}
// 添加配料，钩子方法，子类可以覆盖实现也可以不实现
protected void addIngredients() {
// 默认不添加任何配料
}
// 获取咖啡名称，抽象方法，由子类实现
protected abstract String getCoffeeName();
}
接下来，定义具体的咖啡类，继承自AbstractCoffee并实现它们特有的步骤，如下代码：
// 拿铁咖啡类
class Latte extends AbstractCoffee {
@Override
protected void brewCoffee() {
System.out.println("冲泡拿铁咖啡...");
}
@Override
protected void addIngredients() {
System.out.println("加入牛奶...");
}
@Override
protected String getCoffeeName() {
return "拿铁咖啡";
}
}
// 美式咖啡类
class AmericanCoffee extends AbstractCoffee {
@Override
protected void brewCoffee() {
System.out.println("冲泡美式咖啡...");
}
@Override
protected String getCoffeeName() {
return "美式咖啡";
}
}
最后，编写一个client类CoffeeShop，用于调用具体的咖啡类来制作咖啡，如下代码：
// 咖啡店客户端类
public class CoffeeShop {
public static void main(String[] args) {
// 制作拿铁咖啡
AbstractCoffee latte = new Latte();
latte.prepareCoffee();
// 制作美式咖啡
AbstractCoffee americanCoffee = new AmericanCoffee();
americanCoffee.prepareCoffee();
}
}
运行CoffeeShop的main方法，输出将会是：
准备咖啡豆...
研磨咖啡豆...
冲泡拿铁咖啡...
倒入杯子...
加入牛奶...
拿铁咖啡制作完成！
准备咖啡豆...
研磨咖啡豆...
冲泡美式咖啡...
倒入杯子...
美式咖啡制作完成！
在这个例子中，使用了模板方法来定义咖啡制作的流程，通过在抽象类AbstractCoffee中定义模板方法prepareCoffee，确保了所有咖啡的制作都遵循相同的步骤，同时允许子类（拿铁咖啡、美式咖啡）定制某些步骤（如冲泡咖啡和添加配料），这样做不仅减少了重复代码，还提高了系统的灵活性和可维护性。
核心总结
模板方法模式在日常开发过程中使用的非常多，它能够封装不变部分，扩展可变部分，提取子类中的公共代码，集中到父类中，避免了代码的重复，此外，它还能控制子类的扩展，父类对模板方法进行定义，子类只能对特定步骤进行实现，保证了算法结构的一致性。模板方法也存在很严重缺点，它可能导致每个不同的实现都需要一个子类，这会增加类的数量，并可能使系统更加复杂，当子类存在很多时，会导致系统庞大，不利于维护。
使用模板方法时一定要明确模板方法和具体方法的责任边界，以及它们之间的协作方式，同时，要合理设计模板方法的抽象层次，既要保证足够的通用性，又要避免过度抽象导致的复杂性。
