前言
经过了一段时间的设计模式的学习,感觉自己真的能掌握了JDK源码,比如旧的io类,就是一个装饰模式,你了解了装饰模式的概念,就自然了解为什么io要这样子设计了。
现在学习的一个设计模式功能可以把算法包装起来,叫“模板方法模式”。
模板方法模式
咖啡因饮料冲泡流程
下面我们来开咖啡类和茶类:
public class Coffee {
void prepareRecipe(){
boilWater();
brewCoffeeGrinds();
pourInCup();
addSugarAndMilk();
}
public void boilWater(){
System.out.println("烧开水");
}
public void brewCoffeeGrinds(){
System.out.println("冲泡咖啡");
}
public void pourInCup(){
System.out.println("把咖啡倒入杯中");
}
public void addSugarAndMilk(){
System.out.println("加入糖和牛奶");
}
}
public class Tea {
void prepareRecipe(){
boilWater();
brewTeaGrinds();
pourInCup();
addLemon();
}
public void boilWater(){
System.out.println("烧开水");
}
public void brewTeaGrinds(){
System.out.println("冲泡茶");
}
public void pourInCup(){
System.out.println("把茶倒入杯中");
}
public void addLemon(){
System.out.println("加入柠檬");
}
}
我们很容易就可以发现,很多代码都是相同的。于是乎我们可以把相同的代码抽出。
但是在咖啡和茶的子类里面,我们似乎还是可以抽出一些相同的地方。
进一步的抽出它们:
1.把水煮沸
2.用热水泡咖啡或茶
3.把饮料倒进杯子
4.在饮料内加入适当的调料
咖啡类和茶类可以分为以上的四部。那么我们尝试把prepareRecipe方法抽象化吧。
public abstract class CaffeineBeverage {
void prepareRecipe(){
boilWater();
brew();
pourInCup();
addCondiments();
}
abstract void brew();
abstract void addCondiments();
void boilWater(){
System.out.println("烧开水");
}
void pourInCup(){
System.out.println("倒入杯中");
}
}
于是乎咖啡类和茶类继承最新的CaffeineBeverage抽象类:
public class Coffee extends CaffeineBeverage{
@Override
void brew() {
System.out.println("冲泡咖啡");
}
@Override
void addCondiments() {
System.out.println("加入糖和牛奶");
}
}
public class Tea extends CaffeineBeverage{
@Override
void brew() {
System.out.println("冲泡茶");
}
@Override
void addCondiments() {
System.out.println("加入柠檬");
}
}
我们把咖啡和茶炮制的过程都放到了一个抽象类里面,这个是一个模板。
是咖啡和茶进一步泛华的过程。
认识模板方法
基本上,我们已经实现了模板设计模式。我们来看看下图:
模板方法实现了一个算法的步骤,并允许子类为一个或多个步骤提供实现。
模板方法模式:在一个方法中定义算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法的结构的情况下,重新定义算法的某些步骤。
为模板方法添加一个钩子
如现在我们需要更改需求了,如果消费者不需要添加配料,那么就需要加一个钩子了。
何为钩子呢,其实就是一个返回boolean的方法而已啦,代码如下:
public abstract class CaffeineBeverage {
void prepareRecipe(){
boilWater();
brew();
pourInCup();
if(customerWantsCondiments()){
addCondiments();
}
}
abstract void brew();
abstract void addCondiments();
void boilWater(){
System.out.println("烧开水");
}
void pourInCup(){
System.out.println("倒入杯中");
}
boolean customerWantsCondiments(){
return true;
}
}
添加了钩子方法,我们就可以在子类中使用它了,如果消费者不需要饮料的话就返回false就好了。
JDK中的模板方法模式
我们来排序鸭子吧
假如我们现在需要排序一个鸭子数组,我们需要怎么做呢?
java设计者提供给我们一个方便的模板方法用来排序(java.util.Arrays)。
public static void sort(Object[] a) {
legacyMergeSort(a);
}
/** To be removed in a future release. */
private static void legacyMergeSort(Object[] a) {
Object[] aux = a.clone();
mergeSort(aux, a, 0, a.length, 0);
}
/**
* Src is the source array that starts at index 0
* Dest is the (possibly larger) array destination with a possible offset
* low is the index in dest to start sorting
* high is the end index in dest to end sorting
* off is the offset to generate corresponding low, high in src
* To be removed in a future release.
*/
private static void mergeSort(Object[] src,
Object[] dest,
int low,
int high,
int off) {
int length = high - low;
// Insertion sort on smallest arrays
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low &&
((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
swap(dest, j, j-1);
return;
}
// Recursively sort halves of dest into src
int destLow = low;
int destHigh = high;
low += off;
high += off;
int mid = (low + high) >>> 1;
mergeSort(dest, src, low, mid, -off);
mergeSort(dest, src, mid, high, -off);
// If list is already sorted, just copy from src to dest. This is an
// optimization that results in faster sorts for nearly ordered lists.
if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}
// Merge sorted halves (now in src) into dest
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
}
大家注意上面的那一段:
// Insertion sort on smallest arrays
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low &&
((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
swap(dest, j, j-1);
return;
}
这里就用了设计模板方法了。我们需要的compareTo()方法来填补空缺,这个方法是来自Comparable这个接口的。
现在我们就需要在鸭子类中继承这个Comparable接口实现compareTo()方法了。
“`
public class Duck implements Comparable {
String name;
int weight;
public Duck(String name, int weight) {
this.name = name;
this.weight = weight;
}
@Override
public String toString() {
return "Duck{" +
"name='" + name + '\'' +
", weight=" + weight +
'}';
}
/**
* 这就是排序需要的方法
* 传入的Object也是一个Duck,和本对象做对比
* @param o
* @return
*/
@Override
public int compareTo(Object o) {
Duck duck = (Duck) o;
if (this.weight < duck.weight){
return -1;
}else if (this.weight == duck.weight){
return 0;
}else{
return 1;
}
}
}
这样就可以用Arrays.sort(Object[] a)工具方法来排序数组了。先是比较两个对象的weight的大小,如果后一个比较大,就用swap方法把他们交换。虽然这个模板方法模型和上面讲到的案例可能有所出入,但是他们差不多都是一个意思。就好像现实世界的正方形也不一定是分毫不差的嘛!
总结
模板方法模式:在一个方法中定义算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法的结构的情况下,重新定义算法的某些步骤。