模板方法模式--TemplateMethod

　　模拟场景：一个xxx模型公司要建立一批car。而这些car是有一个统一的模板的，都是由统一的特性的，只是各种特性的在不同的car中各不相同。

　　先分析一下，既然这些car是有一个统一的模板的，模板上定义了这些car统一的特性，如可以开动start、可以停止stop、可以鸣笛alarm、可以启动引擎engineBoom、可以跑动run。

　　那么转换为具体的类文件，也就是说首先要有一个抽象类CarModel，表示car创建的模板，在该类中定义一系列的特性，即定义一系列方法start()、stop()、alart()、engineBoon()、run()，但是要注意的是，run()方法时需要其他方法支持的，也就是说run之前要先开动car（start），启动引擎（engineBoom），鸣笛（alarm），最后要停下来（stop），那么很明显，所有的car在跑动（run）的时候都是要进行同样的一系列操作。所以run()是共有的，也就是说不能定义为abstract，而且既然这些操作要在模板中就定义好，那么就应该把该方法设置为final，表示子类不能进行覆写，这样就可以防止子类的误操作，还有其他特性要统一设置为abstract。

　　注：这里只是简单的举例，这里我的模板规定了在run之前要调用一系列的操作。在实际中要按实际情况进行设计。

　　CarModel：car建立的模板 

package com.zqz.dp.template;
/**
 * @author Qin 生产car的模型，所有的才都按照此模板进行设计
 */
public abstract class CarModel {
         /**
          * 首先car要可以启动起来
          */
         protected abstract void start();
         /**
          * 除了可以开动，car也要可以停止下来
          */
         protected abstract void stop();
         /**
          * car还要可以鸣笛
          */
         public abstract void alarm();
         /**
          * car还要有引擎
          */
         protected abstract void engineBoom();
         /**
          * 定义完规定之后，car要开始进行建立模型，下面就是进行具体的操作。设置为final是为了防止子类破坏进行覆写
          */
         protected final void run() {
                   this.start(); // car开始启动
                   this.engineBoom(); // 引擎启动
                   this.alarm(); // 开始鸣笛
                   this.stop(); // car停下来
         }
}

　　Car1：根据模板CarModel建立的第一辆car1 

package com.zqz.dp.template;
/**
 * @author Qin
 * 第一辆按照CarModel建立的car1
 */
public class Car1 extends CarModel {
         @Override
         public void start() {
                   System.out.println("car1启动");
         }
         @Override
         public void stop() {
                   System.out.println("car1停下来");
         }
         @Override
         public void alarm() {
                   System.out.println("car1鸣笛");
         }
         @Override
         public void engineBoom() {
                   System.out.println("car1启动引擎");
         }
} 

　　Car2：根据模板CarModel建立的第一辆car2 

package com.zqz.dp.template;
/**
 * @author Qin 第二辆按照CarModel建立的car2
 */
public class Car2 extends CarModel {
         @Override
         public void start() {
                   System.out.println("car2启动");
         }
         @Override
         public void stop() {
                   System.out.println("car2停下来");
         }
         @Override
         public void alarm() {
                   System.out.println("car2鸣笛");
         }
         @Override
         public void engineBoom() {
                   System.out.println("car2启动引擎");
         }
}

　　Client：场景类，开始建立car并让car跑动起来 

package com.zqz.dp.template;
/**
 * @author Qin
 * 场景类，主要是按照模板CarModel生成不同的car，并开动起来
 */
public class Client {
         public static void main(String[] args) {
                   System.out.println("-----------建立第一辆car-------------");
                   CarModel car1=new Car1();    //根据模板建立第一辆car1
                   car1.run();        //开始建立car，让car跑动起来
                   System.out.println("-----------建立第二辆car-------------");
                   CarModel car2=new Car2();    //根据模板建立第一辆car2
                   car2.run();        //开始建立car，让car跑动起来
         }
} 

　　模板方法的定义：定义一个操作中的算法框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定的算法。

模板方法的优点：

　　1、  封装不变对象，拓展可变部分：即把不变的部分封装在父类中，这里指的是建立一辆car有什么特性。可变部分交给子类去继承，拓展实现。也就是说如果现在要建立一辆car3，只需要继承CarModel，实现具体方法即可。

　　2、  提取公共代码部分，便于维护：即把共有的，不应该改变的对象封装在父类（抽象类）中，并定义为final，表示不可改变，而其他可变的部分定义成abstract，让子类自己去实现。

　　3、  行为由父类控制，子类实现：基本的方法有子类进行实现

模板方法的缺点

　　在我们传统的设计中，抽象类一般只负责声明最抽象、一般的属性和方法，实现类完成具体的实现。但是在模板方法中，抽象类却定义了部分抽象方法，由子类去实现。也定义了普通的方法，调用抽象方法。也就说说子类覆写的结果会影响到父类的方法。在复杂项目中会带来阅读的难度。

模板方法的使用场景：

　　1、  多个子类有相同的行为操作，且逻辑基本相同

　　2、  重要，复杂的算法

　　3、  重构时可以考虑此模式

模板方法的拓展：

　　模拟场景：现在发现，每一辆car都会产生鸣笛，这样造成了很大的噪音。现在有如下要求，car1根据客户的需求来定义是否需要鸣笛的特性，而car2不存在鸣笛的特性。那么该怎么进行设计呢？

　　分析，其实大方向还是不需要改变的，只是现在需要根据子类来决定父类的操作了，那么我们就可以跟设计一个run方法一样在CarModel中设计一个方法isAlarm()，来返回boolean，用来判断父类是否执行alarm()方法。记住应该是非abstract，非final的，因为car2是不需要鸣笛的，那么我们在父类中就可以默认设置为true，如果有一辆car是需要鸣笛的，那么就可以不用进行覆写。而car1是根据情况进行操作的，所以要进行覆写。其实这个方法就叫做“钩子方法”（Hook Method）。有了钩子方法的模板方法模式才算完美，这样就可以由子类的一个返回值来确定父类的执行结果。

　　修改CarModel 

package com.zqz.dp.template.hookmethod;
/**
 * @author Qin 生产car的模型，所有的才都按照此模板进行设计
 */
public abstract class CarModel {
         /**
          * 首先car要可以启动起来
          */
         protected abstract void start();
         /**
          * 除了可以开动，car也要可以停止下来
          */
         protected abstract void stop();
         /**
          * car还要可以鸣笛
          */
         public abstract void alarm();
         /**
          * car还要有引擎
          */
         protected abstract void engineBoom();
         /**
          * 判断是否需要鸣笛alarm这个特性
          */
         protected boolean isAlarm(){
                   return false;    //默认是不需要鸣笛的
         }
         /**
          * 定义完规定之后，car要开始进行建立模型，下面就是进行具体的操作。设置为final是为了防止子类破坏进行覆写
          */
         protected final void run() {
                   this.start(); // car开始启动
                   this.engineBoom(); // 引擎启动
                   if(this.isAlarm()){     //如果需要鸣笛--具体是否需要交给子类
                            this.alarm(); // 开始鸣笛
                   }
                   this.stop(); // car停下来
         }
} 

　　修改的car1 

package com.zqz.dp.template.hookmethod;
/**
 * @author Qin
 * 第一辆按照CarModel建立的car1
 */
public class Car1 extends CarModel {
         private boolean alarmflag=true;     //标志，用于判断是否需要进行鸣笛的操作，默认需要
         @Override
         public void start() {
                   System.out.println("car1启动");
         }
         @Override
         public void stop() {
                   System.out.println("car1停下来");
         }
         @Override
         public void alarm() {
                   System.out.println("car1鸣笛");
         }
         @Override
         public void engineBoom() {
                   System.out.println("car1启动引擎");
         }
         @Override
         public boolean isAlarm() {
                   return this.alarmflag;//交给alarmflag，外部设置
         }
         public boolean isAlarmflag() {
                   return alarmflag;
         }
         public void setAlarmflag(boolean alarmflag) {
                   this.alarmflag = alarmflag;
         }
} 

　　修改的car2 

package com.zqz.dp.template.hookmethod;
/**
 * @author Qin 第二辆按照CarModel建立的car2
 */
public class Car2 extends CarModel {
         @Override
         public void start() {
                   System.out.println("car2启动");
         }
         @Override
         public void stop() {
                   System.out.println("car2停下来");
         }
         @Override
         public void alarm() {
                   System.out.println("car2鸣笛");
         }
         @Override
         public void engineBoom() {
                   System.out.println("car2启动引擎");
         }
         @Override
         protected boolean isAlarm() {
                   return false; // 不需要鸣笛alarm这个特性
         }
} 

　　修改的场景类Client 

package com.zqz.dp.template.hookmethod;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * @author Qin 场景类，主要是按照模板CarModel生成不同的car，并开动起来
 */
public class Client {
         public static void main(String[] args) {
                   System.out.println("-----------建立第一辆car-------------");
                  Car1 car1 = new Car1(); // 建立第一辆car1
                   BufferedReader buf = new BufferedReader(
                                     new InputStreamReader(System.in)); // 输入流，键盘输入
                   System.out.println("是否需要鸣笛alarm这一特性，输入0代表不需要，输入其他代表需要");
                   String str=null;
                   try {
                            str = buf.readLine();  //等待输入
                   } catch (IOException e) {
                            e.printStackTrace();
                   }       
                   if(str.equals("0")){
                            car1.setAlarmflag(false);         //设置不用鸣笛alarm这一特性
                   }
                   car1.run(); // 开始建立car，让car跑动起来
                   System.out.println("-----------建立第二辆car-------------");
                   CarModel car2 = new Car2(); // 根据模板建立第一辆car2
                   car2.run(); // 开始建立car，让car跑动起来
         }
}