设计模式之:模板模式

1.模板模式就是通过抽象类来定义一个逻辑模板，逻辑框架、逻辑原型，然后将无法决定的部分抽象成抽象类交由子类来实现，一般这些抽象类的调用逻辑还是在抽象类中完成的。这么看来，模板就是定义一个框架

2.定义模板采用抽象类来定义，为什么不是接口呢？因为公共的结构化逻辑需要在抽象类中完成，只将非公共的部分逻辑抽象成抽象方法，留待子类充实实现。

example : 建造房子为例

共有的行为：1.安装门 2.安装窗户
共有的逻辑：建房子（需要 1.安装门 2.安装窗户）

模板抽象类：HouseTemplate

public abstract class HouseTemplate {
  
      protected HouseTemplate(String name){
          this.name = name;
      }
  	
      protected String name;
  
      protected abstract void buildDoor();
 
     protected abstract void buildWindow();
 
     //公共逻辑
     public final void buildHouse(){
     
         buildDoor();
         buildWindow();
      }
  }

子类1：HouseOne：

 public class HouseOne extends HouseTemplate {
  
     HouseOne(String name){
         super(name);
     }
 
     @Override
     protected void buildDoor() {
          System.out.println("采用防盗门");
     }
 
     @Override
     protected void buildWindow() {
         System.out.println("落地窗");
     }     
 }

子类2：HouseTwo：

 public class HouseTwo extends HouseTemplate {
  
     HouseTwo (String name){
         super(name);
     }
 
     @Override
     protected void buildDoor() {
          System.out.println("双层防盗门");
     }
 
     @Override
     protected void buildWindow() {
         System.out.println("小窗户");
     }     
 }

模拟调用

public class Clienter {
 
      public static void main(String[] args){
          HouseTemplate houseOne = new HouseOne("房子1");
          HouseTemplate houseTwo = new HouseTwo("房子2");
          houseOne.buildHouse();
          houseTwo.buildHouse();
      }  
}

二 钩子
1.其实，模板模式中还有一个钩子方法的概念
2.钩子干啥的呢？钩子就是给子类一个授权，允许子类通过重写钩子方法来颠覆基本逻辑的执行，这有时候是非常有用的。就比如在盖房子的时候，有一个需要子类来决定是否建造厕所间的需求时，可以这么实现：

模板抽象类：HouseTemplate

public abstract class HouseTemplate {
  
      protected HouseTemplate(String name){
          this.name = name;
      }
  
      protected String name;
  
      protected abstract void buildDoor();
 
     protected abstract void buildWindow();
	 //建厕所方法
     protected abstract void buildToilet();
 
     //钩子方法  是否建厕所
     protected boolean isBuildToilet(){
         return true;
     }
 
     //公共逻辑
     public final void buildHouse(){
         buildDoor();
         buildWindow();
         if(isBuildToilet()){
             buildToilet();
         }
     }
 }

子类1：HouseOne

public class HouseOne extends HouseTemplate {
 
      HouseOne(String name){
          super(name);
      }
  
      HouseOne(String name, boolean isBuildToilet){
          this(name);
          this.isBuildToilet = isBuildToilet;
     }
 
     public boolean isBuildToilet;
 
     @Override
     protected void buildDoor() {
         System.out.println(name +"的门要采用防盗门");
     }
 
     @Override
     protected void buildWindow() {
         System.out.println(name + "的窗户要面向北方");
     }
 
     @Override
     protected void buildToilet() {
         System.out.println(name + "的厕所建在东南角");
     }
 
     @Override
     protected boolean isBuildToilet(){
        //是否建造厕所
         return isBuildToilet;
     }
 
 }

模板模式的关键点：

1. 使用抽象类定义模板类，并在其中定义所有的基本方法、模板方法，钩子方法，不限数量，以实现功能逻辑为主。其中基本方法使用final修饰，其中要调用基本方法和钩子方法，基本方法和钩子方法可以使用protected修饰，表明可被子类修改。

2. 定义实现抽象类的子类，重写其中的模板方法，甚至钩子方法，完善具体的逻辑。

使用场景：

1. 在多个子类中拥有相同的方法，而且逻辑相同时，可以将这些方法抽出来放到一个模板抽象类中。
2. 程序主框架相同，细节不同的情况下，也可以使用模板方法。