设计模式之模板方法模式
模板方法模式定义了一套算法调用步骤的模板，通过继承，子类可以对一个或多个步骤提供实现。当需要扩展时，只需要添加子类即可，而且子类可以复用父类的代码。
模板方法模式的类图如下：
下面以泡茶和冲咖啡为例
抽象出泡茶和冲咖啡的咖啡因饮料类
/**
定义了模板方法的类,抽象出咖啡和茶的咖啡因饮料类
**/
public abstract class CaffeineBeverage
{
/**
模板方法，调用一系列的步骤，实现制作饮料的步骤
**/
public final void prepareRecipe()
{
boilWater();
brew();
pourInCup();
if(custormerWantCondiments())
addCondiments();
}
/**
由于把水煮沸的步骤对于任何饮料都是一样的，则父类直接实现该方法
**/
public void boilWater()
{
System.out.println("boil water");
}
public abstract void brew();
public abstract void addCondiments();
public void pourInCup()
{
System.out.println("pour In cup");
}
/**
子类可以选择实现的“钩子”方法
**/
public boolean custormerWantCondiments()
{
return true;
}
}
Tea类
/**
继承了模板方法的类Tea,没有实现钩子方法
**/
public class Tea extends CaffeineBeverage
{
public void brew()
{
System.out.println("Steeping the tea");
}
public void addCondiments()
{
System.out.println("adding lemon");
}
}
Coffee类
import java.io.*;
/**
继承了模板方法的类Coffee类
**/
public class Coffee extends CaffeineBeverage
{
public void brew()
{
System.out.println("Dripping Coffee through filter");
}
public void addCondiments()
{
System.out.println("adding sugar");
}
/**
子类可以选择实现的“钩子”方法
**/
public boolean custormerWantCondiments()
{
String answer=getUserInput();
if(answer.equals("y"))
{
return true;
}
return false;
}
private String getUserInput()
{
String answer=null;
System.out.println("would you like milk and sugar in your coffee?");
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
try
{
answer=in.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
if(answer==null)
{
return "n";
}
return answer;
}
}
测试类
public class Test
{
public static void main(String[] args)
{
Coffee coffee=new Coffee();
System.out.println("Making coffee....");
coffee.prepareRecipe();
Tea tea=new Tea();
System.out.println("Making tea....");
tea.prepareRecipe();
}
}
运行结果
可以看出模板方法定义的步骤里面有三种不同类型的方法：
1.由父类直接实现的方法：比如上例中的boilWater和pourInCup方法，对于Coffee和Tea来说，都是一样的，所以可以复用，可以定义为final
2.由子类实现的方法：比如上例中的brew方法
3.子类可选择实现的方法,比如上例中的customerWantCondiments（）方法。
由模板方法模式中的“钩子”，可以引申出一个设计原则——“好莱坞原则”，“别电话给我，我会打电话给你”，就是说，低层组件可以将自己挂钩到系统上，但是由高层组件决定什么时候和怎样使用这些底层组件，所以对于高层组件来说，其对待低层组件的方式是“别调用我，我会调用你们”。像上例中的customerWantCondiments()方法，就是由子类实现，父类调用。
模板方法的应用之一是用模板方法排序。
Arrays类中提供了一个sort方法，sort方法实际上调用了一个私有的mergeSort()方法
mergeSort方法是一个模板方法，我们可以通过改变比较的条件实现自己的排序，我们需要实现的是Comparable接口中的compareTo()方法。
比如说我们要将学生按成绩排序。
写一个Student类，实现Comparable接口
public class Student implements Comparable
{
public int score;
public String name;
public Student(String name,int score)
{
this.name=name;
this.score=score;
}
public int compareTo(Object object)
{
Student otherStudent=(Student)object;
if(this.score>otherStudent.score)
{
return 1;
}
else if(this.score==otherStudent.score)
{
return 0;
}
else
{
return -1;
}
}
}
测试类
import java.util.*;
public class TestSort
{
public static void main(String[] args)
{
Student[] stu={
new Student("qing",100),
new Student("chen",90),
new Student("zhou",80),
new Student("ddd",50)
};
System.out.println("before sorting....");
display(stu);
System.out.println("after sorting....");
Arrays.sort(stu);
display(stu);
}
public static void display(Student[] stu)
{
for(Student s:stu)
{
System.out.println(s.name+"\t"+s.score);
}
}
}
运行结果是
模板方法模式，策略模式，工厂方法模式的比较
