关键词 ：hook 钩子 Applet 中 init() destory() 为钩子，需要子类去实现。
新原则： 别调用我们，我们会调用你们 高层调用低层 低层不能调用高层。
目的 ：封装算法
模板方法：子类决定如何实现算法中的步骤
策略：封装可互换的行为，然后使用委托来决定要采用哪一个行为
工厂方法：由子类决定实例化哪个具体类
OO原则：新原则上面
OO模式：模板方法模式：在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类。模板方法使得子类可以在不改变算法的结构的情况下，重新定义算法中的某些步骤。
abstract class AbstractClass{<span style="white-space:pre"> </span>final void templateMethod(){<span style="white-space:pre"> </span> primitiveOperation1(); // 抽象方法
primitiveOperation2();
concreteOperation(); //final 的
hook();
}
<span style="white-space:pre"> </span>abstract void primitiveOperation1(); //这两个方法由具体子类实现 。
<span style="white-space:pre"> </span>abstract void primitiveOperation2();
final void concreteOperation(){// 这里是实现 //这个具体的方法定义在抽象类中将它声明为final，这样一来子类就无法覆盖它，它可以被模板方法直接使用或被子类使用
}
void hook(){} //钩子 这是一个具体的方法，但它什么事情都不做 称为 hook 子类可以视情况决定要不要覆盖它们。
}钩子是一种被声明在抽象类中的方法，但只有空的或者默认的实现。钩子的存在，可以让子类有能力对算法的不同点进行挂钩。要不要挂钩，由子类决定。
public abstract class CaffeineBeverageWithHook{ void PrepareRecipe(){<span style="white-space:pre"> </span>brew();
pourInCup();
if(<span style="color:#ff6666;">customerWantsCondiments</span>()){ //如果 “ 想要 ”调料， 才添加调料 ， 调用的钩子。addCondiments();
}
}
abstract void brew();
void pourInCup(){<span style="white-space:pre"> </span>syso.
}
boolean customerWantsCondiments(){ //这就是一个钩子，子类可以覆盖这个方法，但不见得一定要这么做。<span style="white-space:pre"> </span>return true;
} }钩子可以做为条件控制语句，影响抽象类中的算法流程。
钩子的另一个用法，是让子类能够有机会对模板方法中某些即将发生的（或刚刚发生的）步骤作出反应。
新原则和依赖倒置原则：依赖倒置原则教我们尽量避免使用具休类，而多使用抽象类。
新原则是用在创建框架或组件上的一种技巧，好让低层组件能够被挂钩进计算中，而且又不会让高层组件依赖低层组件。两者的目标都是在于解耦。
JavaAPI 中的 模板方法
Arrays.Sort()
Java数组类的设计者提供一个模板方法用来排序。 下面是简化代码
public static void sort(Object[] a){ //此方法只是一个辅助方法，用来创建一个数组的拷贝，然后将其传给mergetSort()方法当作目标数组。
Object aux[] =(Object)a.clone(); mergeSort(aux,a,0,a.length,0); //mergeSort() 方法包含排序算法， 此算法依赖于 compareTo()方法的实现来完成算法。 }
private static void mergeSort(Object src[],Object dest[],int low,int high,int off){ //把这想像成一个模板方法 for(int i =low;i<high;i++){<span style="white-space:pre"> </span>for(int j=i;j>low && ((Comparable)dest[j-1]).compareTo((Compareable)dest[j])>0;j--){ //我们需要实现compareTo()方法 ，“填补”模板方法<span style="white-space:pre"> </span>swap(dest,j,j-1); //这是一个具体的方法，已经在数组类中定义了。
}
}
return ;
}数组无法继承，所以如何使用sort() ?
sort()的设计者希望这个方法能用于所有的数组，所以把sort()变成静态的方法，这样任何数组都能使用这个方法。
因为sort()并不是真正定义在超类中，所以sort()方法需要知道你已经实现了这个compareTo()方法，否则无法进行排序。
所以数组中要排序的对象需要实现 Comparable接口。
例子： 比较鸭子
public class Duck implements Comparable{int weight; //重量
public int compareTo(Object object){ //此方法需要传入别一只鸭子，和本身这只鸭子做比较<span style="white-space:pre"> </span>Duck otherDuck = (Duck)object;
if(this.weight<otherDuck.weight){return -1;
}else if (this.weight==otherDuch.weight){return 0;
}else{<span style="white-space:pre"> </span> return 1;
}<span style="white-space:pre"> </span>
} }开始排序
public class DuckSortTest{
public static void main(String args[]){ Duck[] ducks = { new Duck("daffy",8), new Duck("dewey",2), new Duck("Howard",7)};
<pre name="code" class="html"> display(ducks);
Arrays.sort(ducks); //调用Arrays 的静态方法sort() 把 鸭子数组当用参数传进去
display(ducks);
public stati void disply(Duck[] ducks){ for(int i=0;i<ducks.length;i++){syso(ducks[i]);
}
}
} }
（１）“模板方法”定义了算法的步骤，把这些步骤的实现延迟到子类
（２）模板方法模式为我们提供了一种代码复用的重要技巧。
（３）模板方法的抽象类可以定义具体方法，抽象方法和钩子。
（４）抽象方法由子类实现。
（５）钩子是一种方法，它在抽象类中不做事，或者只做默认的事情，子类可以选择要不要去覆盖它。
（６）为了防止子类改变模板方法中的算法，可以将模板方法声明为final
（7）好莱坞原则告诉我们，将决策权放在高层模块中，以便决定如何以及何时调用低层模块。
（8）你将在真实世界代码中看到模板方法模式的许多变体，不要期待它们全都是一眼就可以被你认出的。
（9）策略模式和模板方法模式都封装算法，一个用组合，一个用继承。
（10）工厂方法是模板方法的一种特殊版本。
策略VS 模板
策略：我定义一个算法家族，并让这些算法可以互换。正因为每一个算法都被封装起来了，所以客户可以轻易地使用不同的算法。
模板：我定义一个算法大钢，而由我的子类定义其中某些步骤可以有不同的实现细节。但是我的算法结构依然维持不变。
模板依赖性高一些，必须依赖超类中算法的实现，因为这是算法的一部分。
策略不依赖任何，整个算法自己搞定。
设计模式(8)--模板方法模式,布布扣,bubuko.com
原文：http://blog.csdn.net/qq717559128/article/details/26385707