Head First 设计模式之模版方法模式(Java例子)

前言：

来源于《head first 设计模式》。当作读书笔记了，这次看的是第8章模版方法模式。难顶呀每晚看完书，第二天早上总结。理解到了以前学习java、spring中的一些基础的概念，蛮有用的，希望自己可以一直坚持下去吧。

模版方法模式的概念

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

模版方法模式的uml图

• AbstractClass:在templateMethod中定义了算法的骨架，具体的实现方法operation1、2交给子类来实现
• ConcreteClass:实现operation1、2算法。
  例子：
• 咖啡冲泡法：
  1.把水煮沸
  2.用沸水冲泡咖啡
  3.把咖啡倒进杯子
  4.加糖和牛奶
• 茶冲泡法
  1.把水煮沸
  2.用沸水冲泡茶叶
  3.把茶倒进杯子
  4.加柠檬

茶和咖啡的基类—AbstractClass

public abstract class CaffeineBeverage {
    // 现在，用同一个prepareRecipe()方法来处理茶和咖啡。
    // prepareRecipe()方法被声明为final，因为我们不希望子类覆盖这个方法
    // 我们将第2步和第4步泛化成为brew()和addCondiments()
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        addCondiments();
    }

    // 因为咖啡和茶处理这些方法的做法不同，所以这两个方法必须被声明为抽象，
    // 剩余的东西留给子类去操心
    abstract void addCondiments();
    abstract void brew();

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

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

coffee和茶的实现类

实现对应的算法骨架中，自己改变的那部分方法。

public class Coffee extends CaffeineBeverage {
    @Override
    void brew() {
        System.out.println("Dripping coffee through filter");
    }

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

public class Tea extends CaffeineBeverage {
    @Override
    void brew() {
        System.out.println("Steeping the tea");
    }

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

hook钩子方法的使用

public abstract class CaffeineBeverageWithHook {
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        // 我们加上了一个小小的条件语句，而该条件是否成立，
        // 是由一个具体方法customerWantsCondiments()决定的。
        // 如果顾客“想要”调料，只有这时我们才调用addCondiments()。
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    abstract void addCondiments();
    abstract void brew();

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

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

    // 我们在这里定义了一个方法，（通常）是空的缺省实现。这个方法只会返回true，不做别的事。
    // 这就是一个钩子，子类可以覆盖这个方法，子类通过覆盖这个钩子来提供自己对于某部分算法的取舍。
    boolean customerWantsCondiments() {
        return true;
    }
}

hook方法子类实现

public class TeaWithHook extends CaffeineBeverageWithHook {
 
	public void brew() {
		System.out.println("Steeping the tea");
	}
 
	public void addCondiments() {
		System.out.println("Adding Lemon");
	}
 
	public boolean customerWantsCondiments() {

		String answer = getUserInput();

		if (answer.toLowerCase().startsWith("y")) {
			return true;
		} else {
			return false;
		}
	}
 
	private String getUserInput() {
		// get the user's response
		String answer = null;

		System.out.print("Would you like lemon with your tea (y/n)? ");

		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		try {
			answer = in.readLine();
		} catch (IOException ioe) {
			System.err.println("IO error trying to read your answer");
		}
		if (answer == null) {
			return "no";
		}
		return answer;
	}
}

测试代码

public class BeverageTestDrive {
	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.prepareRecipe();

 
		TeaWithHook teaHook = new TeaWithHook();
 
		System.out.println("\nMaking tea...");
		teaHook.prepareRecipe();
	}
}

总结

Java中也有模板方法的体现。那就是对数组进行排序的时候实现Comparable接口，提供这个接口所声明的compareTo()方法。
策略模式与模版模式的不同：
则略模式：针对整个算法的实现，用所组合的类实现了整个算法，委托的方式实现。
模版模式：针对算法中的每个步骤，采用继承的形式来实现，让子类来重写需要修改的算法步骤。