HeadFirst 设计模式学习之模板方法模式

HeadFirst 设计模式学习之模板方法模式

模板方法定义

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

demo演示–泡茶和冲咖啡

分析：

泡茶和冲咖啡都可以分成下面四个步骤：

• 把水烧热
• 冲泡茶/咖啡
• 将茶/咖啡倒入杯子

• 加入合适的调料（茶可以放柠檬，咖啡放糖）

  定义算法骨架：

      void preparRecipe()
  {
      boilWater();    //烧水
      brew();         //冲泡
      pourInCup();    //倒入杯子
      addCondiments();//加调料
  }
  

  上面的骨架中，咖啡和茶烧水喝倒入杯子的过程是完全相同的，所以定义在基类中，其他两个方法则有子类负责实现。

  基类

  abstract class Beverage {
  public final void preparRecipe()
  {
      boilWater();    //烧水
      brew();         //冲泡
      pourInCup();    //倒入杯子
      addCondiments();//加调料
  }
  
   public abstract void addCondiments();
  
  public void pourInCup() {
      // TODO Auto-generated method stub
      System.out.println("pourInCup-------");
  }
  
  public abstract void brew() ;
  
  public  void boilWater() {
      // TODO Auto-generated method stub
      System.out.println("BoilWater-------");
  }
  
  }
  

  子类Tea

  class Tea extends Beverage {
  
  @Override
  public void addCondiments() {
      // TODO Auto-generated method stub
      System.out.println("add Condiment to tea-------");
  }
  
  @Override
  public void brew() {
      // TODO Auto-generated method stub
      System.out.println("brew tea-------");
  }
  
  }
  

  咖啡类与茶类相似，代码就不再贴出。

  测试代码及结果：
  public static void main(String[] args) {
      // TODO Auto-generated method stub
      new Tea().preparRecipe();
  }
  BoilWater-------
  brew tea-------
  pourInCup-------
  add Condiment to tea-------
  

再进一步，模板方法与钩子

在上一个部分中，我们定义了一个含有四个部分的算法骨架，其中两个部分交给子类去实现，另外两个由基类实现。这样做，对于基类来说，屏蔽了算法的某些细节，而子类负责实现这些细节，从而将自己挂载到算法当中去,而钩子则能够改变算法流程。

钩子的魅力——灵活的加入调料

先对上面的基类做出以下修改：

• 加入方法getAns（），用来得到是否需要调料。
• 将该方法放入preparRecipe()。

修改完的类：

abstract class Beverage {
public final void preparRecipe()
{
    boilWater();    //烧水
    brew();         //冲泡
    pourInCup();    //倒入杯子
    if(getAns())
    addCondiments();//加调料
}

 public abstract void addCondiments();

public void pourInCup() {
    // TODO Auto-generated method stub
    System.out.println("pourInCup-------");
}

public abstract void brew() ;

public  void boilWater() {
    // TODO Auto-generated method stub
    System.out.println("BoilWater-------");
}
public boolean getAns()
{
    return true; //默认是加调料的
}
}

Tea类复写方法getAns()

public boolean getAns() {
    // TODO Auto-generated method stub
    System.out.println("是否加入调料：（Y/N）");
    BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
    try {
        if("Y".equals(in.readLine()))
        {
            return true;
        }

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return false;
}

运行结果：

BoilWater-------
brew tea-------
pourInCup-------
是否加入调料：（Y/N）
Y
add Condiment to tea-------

上述过程中，子类通过复写了基类的方法来达到改变算法流程的目的（是否执行addCondiments()方法），这就是钩子的用法。

涉及的原则：好莱坞原则

好莱坞原则：别调用我们，我们会调用你。

好莱坞原则是防止“依赖腐败”（高层和低层相互依赖）的方法，它让高层决定流程（什么时候调用低层），低层决定某些细节。