模板方法模式让子类在不改变算法整体结构的前提下定制特定步骤，例如咖啡制作，不同咖啡遵循相同流程但有独特定制，如拿铁加牛奶，美式不加，这确保了制作流程的一致性，同时满足了不同咖啡的个性化需求，体现了模板方法模式的核心思想。

定义

模板方法模式是一种行为设计模式，它在一个方法中定义了一个算法的骨架，允许子类在不改变算法结构的情况下，对算法的某些步骤中的内容进行定制。

举一个现实中的例子：假设有一家咖啡店，店中提供多种咖啡，比如拿铁、美式、卡布奇诺等，虽然这些咖啡的制作过程有所不同，但它们都遵循一个基本的制作流程：准备咖啡豆、研磨咖啡豆、冲泡咖啡、倒入杯子、加入配料（如牛奶、糖等）、完成制作。

在这个例子中，制作咖啡的流程就是一个模板方法，它定义了一个算法的骨架，不同的咖啡（拿铁、美式、卡布奇诺等）就是这个模板方法的具体实现，它们会在算法的某些步骤上进行定制，比如，拿铁咖啡在冲泡后会加入牛奶，而美式咖啡则不会；卡布奇诺咖啡可能会在冲泡前多加入一些研磨后的咖啡豆，以增强咖啡的口感。

通过这种方式，可以确保每一种咖啡的制作都遵循基本的流程，同时又可以根据具体咖啡的需求对流程中的某些步骤进行定制，这就是模板方法的核心思想。

代码案例

正例

下面是一个未使用模板方法的反例代码，在这个例子中，假设有一个咖啡制作系统，其中包含了制作不同种类咖啡的方法，但由于没有使用模板方法，这些方法之间会存在大量的重复代码。

先定义一个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，确保了所有咖啡的制作都遵循相同的步骤，同时允许子类（拿铁咖啡、美式咖啡）定制某些步骤（如冲泡咖啡和添加配料），这样做不仅减少了重复代码，还提高了系统的灵活性和可维护性。

核心总结

模板方法模式在日常开发过程中使用的非常多，它能够封装不变部分，扩展可变部分，提取子类中的公共代码，集中到父类中，避免了代码的重复，此外，它还能控制子类的扩展，父类对模板方法进行定义，子类只能对特定步骤进行实现，保证了算法结构的一致性。模板方法也存在很严重缺点，它可能导致每个不同的实现都需要一个子类，这会增加类的数量，并可能使系统更加复杂，当子类存在很多时，会导致系统庞大，不利于维护。

使用模板方法时一定要明确模板方法和具体方法的责任边界，以及它们之间的协作方式，同时，要合理设计模板方法的抽象层次，既要保证足够的通用性，又要避免过度抽象导致的复杂性。