模板方法（类行为型）

1.行为型设计模式主要关注对象之间职责分配和算法的问题，类行为型模式使用继承来分配类之间的职责。

2.模板方法：父类先定义好一个模板，如一个算法的执行流程，子类继承它的时候就会按照父类定义好的流程走，子类也不用关心这个流程的实现，子类在不改变它的算法架构下，可以重新定义算法中的一些新的方法。其中算法的结构可理解为根据需求设计出来的业务流程。模板方法实际上是利用多态这种晚绑定机制来将一些执行系列延迟到子类(运行时)。

模板方法多用在：

• 某些类别的算法中，实做了相同的方法，造成程式码的重复。

• 控制子类别必须遵守的一些事项。

• 一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

• 各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。

abstract class Game {
 
     private int playersCount;
 
     abstract void initializeGame();
 
     abstract void makePlay(int player);
 
     abstract boolean endOfGame();
 
     abstract void printWinner();
 
     /* 先定义一个模板 */
     final void playOneGame(int playersCount) {
         this.playersCount = playersCount;
         initializeGame();
         int j = 0;
         while (!endOfGame()){
             makePlay(j);
             j = (j + 1) % playersCount;
         }
         printWinner();
     }
 }

class Monopoly extends Game {
 
     /* Implementation of necessary concrete methods */
 
     void initializeGame() {
         // ...
     }
 
     void makePlay(int player) {
         // ...
     }
 
     boolean endOfGame() {
         // ...
     }
 
     void printWinner() {
         // ...
     }
 
     /* Specific declarations for the Monopoly game. */
 
     // ...
 
 }

class Chess extends Game {
 
     /* Implementation of necessary concrete methods */
 
     void initializeGame() {
         // ...
     }
 
     void makePlay(int player) {
         // ...
     }
 
     boolean endOfGame() {
         // ...
     }
 
     void printWinner() {
         // ...
     }
 
     /* Specific declarations for the chess game. */
 
     // ...
 
 }

测试类：

public class Player {

   public static void main(String[] args) {
       Game chessGame = new Chess();
       chessGame.initializeGame();
       chessGame.playOneGame(1); //call template method
   }

}

模板方法模式的优点：
1)模板方法模式在一个类中形式化地定义算法，而由它的子类实现细节的处理。
2)模板方法是一种代码复用的基本技术。它们在类库中尤为重要，它们提取了类库中的公共行为。

3)模板方法模式导致一种反向的控制结构，这种结构有时被称为“好莱坞法则” ，即“别找我们，,我们找你”通过一个父类调用其子类的操作(而不是相反的子类调用父类)，通过对子类的扩展增加新的行为，符合“开闭原则”

模板方法模式的缺点:

每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象，但是更加符合“单一职责原则”，使得类的内聚性得以提高。