设计模式之禅之模版方法模式

我们来已车子为例。

悍马车有两个型号，H1和H2。代码如下：

抽象悍马模型：

public abstract class HummerModel {
	public abstract void start();//开车
	public abstract void stop();//停车
	public abstract void alarm();//喇叭
	public abstract void engineBoom();//引擎
	public abstract void run();//会跑

}

在抽象中，我们定义了悍马模型都必须具有的特征：能发动、停止、喇叭会响、引擎可以轰鸣、而且还能停止，但是每个型号的悍马实现是不同的。代码如下：

H1型号悍马模型：

public class HummerH1Model extends HummerModel{

	@Override
	public void start() {
		System.out.println("悍马H1发动");
		
	}

	@Override
	public void stop() {
		System.out.println("悍马H1停车");
		
	}

	@Override
	public void alarm() {
		System.out.println("悍马H1鸣笛");
		
	}

	@Override
	public void engineBoom() {
		System.out.println("悍马H1引擎");
		
	}

	@Override
	public void run() {
		//先发动
		this.start();
		//引擎开始轰鸣
		this.engineBoom();
		//然后遇到障碍按喇叭
		this.alarm();
		//到达目的地停车
		this.stop();
		
	}

}

大家注意里面的run方法，这是一个汇总方法，一个模型生产成功了，必须让他跑起来检测一下。

H2型号悍马模型

public class HummerH2Model extends HummerModel{

	@Override
	public void start() {
		System.out.println("悍马H2发动");
		
	}

	@Override
	public void stop() {
		System.out.println("悍马H2停车");
		
	}

	@Override
	public void alarm() {
		System.out.println("悍马H2鸣笛");
		
	}

	@Override
	public void engineBoom() {
		System.out.println("悍马H2引擎");
		
	}

	@Override
	public void run() {
		//先发动
		this.start();
		//引擎开始轰鸣
		this.engineBoom();
		//然后遇到障碍按喇叭
		this.alarm();
		//到达目的地停车
		this.stop();
		
	}

}

写到这里我们发现了问题，两个实现类里run方法是相同的，那这个run方法应该出现在抽象类中的，不应该在实现类中， 抽象是所有子类的共性封装。

修改后的抽象悍马模型：

public abstract class HummerModel {
	public abstract void start();//开车
	public abstract void stop();//停车
	public abstract void alarm();//喇叭
	public abstract void engineBoom();//引擎
	public void run(){
		//先发动汽车
		this.start();
		//引擎开始轰鸣
		this.engineBoom();
		//然后遇到障碍按喇叭
		this.alarm();
		//到达目的地停车
		this.stop();
	}

}

在悍马抽象模型中已经定义了run方法的执行规则，先启动，然后引擎轰鸣，中间要按喇叭，然后停车，他们两个具体的实现类就不需要实现run方法了。只要把实现类的run方法删除即可。

场景类实现的任务就是把生产出的模型展现给客户，代码如下：

场景类：

public class Client {
	public static void main(String[] args) {
		//公司要H1型号的悍马
			HummerModel h1 = new HummerH1Model();
			//H1模型展示
			h1.run();
			
	}
}

运行结果如下：

悍马H1发动
悍马H1引擎
悍马H1鸣笛
悍马H1停车

目前客户只要看H1型号的悍马车，没有问题，生产出来了。这就是模版方法模式。非常简单的。

模板方法模式的定义：

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

模版方法模式仅仅使用了java的继承机制，但他是一个应用非常广泛的模式。其中AbstractClass叫做抽象模板，他的方法分为两类：

1基本方法:

也叫做基本操作，是由子类实现的方法，并且在模板方法被调用。

2模板方法：

可以有一个或者几个，一般是一个具体方法，也就是一个框架。实现对基本方法的调度，完成固定的逻辑。

下面我们来用代码看看：

抽象模板类：

public abstract class AbstractClass {
	//基本方法
	protected abstract void doSomething();
	//基本方法
	protected abstract void doAnything();
	//模板方法
	public void templateMethod(){
		/**
		 * 调用基本方法，完成相关逻辑
		 */
		this.doAnything();
		this.doSomething();
	}

}

具体模板类：

public class ConcreteClass1 extends AbstractClass{
//基本实现方法
	@Override
	protected void doSomething() {
		//业务逻辑处理
		
	}

	@Override
	protected void doAnything() {
		//业务逻辑处理
		
	}

}

public class ConcreteClass2 extends AbstractClass{
//基本实现方法
	@Override
	protected void doSomething() {
		//业务逻辑处理
		
	}

	@Override
	protected void doAnything() {
		//业务逻辑处理
		
	}

}

场景类：

public class Client {
	public static void main(String[] args){
		AbstractClass class1 = new ConcreteClass1();
		AbstractClass class2 = new ConcreteClass2();
		//调用模板方法
		class1.templateMethod();
		class2.templateMethod();
	}

}

抽象模板中的基本方法尽量用protected类型，符合迪米特法则，不需要暴露的属性活方法尽量不要设置为protected类型。实现类若非必要，尽量不要扩大父类中的访问权限。

模板方法模式的优点：

·封装不变部分，扩展可变部分

把认为不变部分的算法封装到父类实现，而可变部分的则可以通过继承来继续扩展。在悍马模型例子中，就非常容易扩展了，例如：增加一个悍马H3，只需要增加一个子类实现父类的基本方法就可以了。

·提取公共部分代码，便于维护

·行为由父类控制，子类实现

基本方法是由子类实现的，因此子类可以通过扩展的方式增加响应的功能，符合开闭原则。

模板方法模式的缺点：

按照我们的设计习惯，抽象类负责声明最抽象、最一般的事物属性和方法，实现类完成具体的事务属性和方法，但是模板方法模式却颠倒了，抽象类定义了部分抽象方法，由子类去实现，子类执行的结果影响了父类的结果，也就是子类对父类产生了影响，在复杂的项目中，会带来代码阅读的难度。

模板方法模式使用的场景：

·多个子类有共有的方法，并且逻辑基本相同时；

·重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能由各个子类实现，

·重构时，模板方法是一个经常使用的模式，把相同的代码抽取到父类中，然后通过钩子函数约束其行为。

模板方式模式的扩展：：

突然有一点，出现了一个需求，就是要H2型号的悍马喇叭不要有声音。

扩展后的抽象模板类：

public abstract class HummerModel {
	protected abstract void start();
	protected abstract void stop();
	protected abstract void alarm();
	protected abstract void engineBoom();
	final public void run(){
		this.start();
		this.engineBoom();
		if(this.isAlarm()){
			this.alarm();
		}
		this.stop();
	}
	//钩子方法
	protected boolean isAlarm(){
		return true;
	}

}

在抽象类，isAlarm是一个实现方法，作用是模板方法根据返回值决定喇叭要不要响，子类可以覆写该返回值，由于H1型号的喇叭是想让他响就响，不想让他响就不响，由人控制。代码如下：

扩展后的悍马H1：

public class HummerH1Model extends HummerModel{
	private boolean alarmFlag = true;//默认响喇叭

	@Override
	protected void start() {
		System.out.println("悍马H1发动");
		
	}

	@Override
	protected void stop() {
		System.out.println("悍马H1停车");
		
	}

	@Override
	protected void alarm() {
		System.out.println("悍马H1鸣笛");
		
	}

	@Override
	protected void engineBoom() {
		System.out.println("悍马H1引擎");
		
	}
	//要不要响喇叭由客户决定的
	public void setAlarm(boolean isAlarm){
		this.alarmFlag = isAlarm;
	}

}

 只要调用H1型号的悍马，默认是喇叭响的。你也可以通过isAlarm(false)来实现。

扩展后的H2悍马：

public class HummerH2Model extends HummerModel{

	@Override
	protected void start() {
		System.out.println("悍马H2发动");
		
	}

	@Override
	protected void stop() {
		System.out.println("悍马H2停车");
		
	}

	@Override
	protected void alarm() {
		System.out.println("悍马H2鸣笛");
		
	}

	@Override
	protected void engineBoom() {
		System.out.println("悍马H2引擎");
		
	}
	//默认没有喇叭
	protected boolean isAlarm(){
		return false;
	}

}

H2型号悍马设置返回值是false，也就是关闭了喇叭功能。

场景类如下：

public class Client {
	public static void main(String[] args)throws IOException{
		System.out.println("------H1型号悍马------");
		System.out.println("H1型号的悍马是否需要喇叭响？ 0-不需要      1-需要");
		String type = (new BufferedReader(new InputStreamReader(System.in))).readLine();
		HummerH1Model h1 = new HummerH1Model();
		if(type.equals("0")){
			h1.setAlarm(false);
		}
		h1.run();
		System.out.println("\n------H2型号悍马------");
		HummerH2Model h2  = new HummerH2Model();
		h2.run();
		
	} 

}

运行是交互的。首先要求输入H1型号悍马是否有声音。如下所示：

------H1型号悍马------
H1型号的悍马是否需要喇叭响？ 0-不需要      1-需要
0
悍马H1发动
悍马H1引擎
悍马H1停车

------H2型号悍马------
悍马H2发动
悍马H2引擎
悍马H2停车

------H1型号悍马------
H1型号的悍马是否需要喇叭响？ 0-不需要      1-需要
1
悍马H1发动
悍马H1引擎
悍马H1鸣笛
悍马H1停车

------H2型号悍马------
悍马H2发动
悍马H2引擎
悍马H2停车

H1型号的悍马由客户控制是否要响喇叭，也就是说外界条件改变，影响到了模板方法的执行，在抽象类中isAlarm返回值就是影响了模板方法的执行结果，该方法叫钩子方法。

模板方法模式就是在模板方法中按照一定的规则和顺序调用基本方法，具体到前面那个例子，就是run方法按照规定的顺序调用本类的其他方法，并且由isAlarm方法的返回值确定run中执行顺序的改变。

初级程序员在写程序时候问高手，父类怎么调用子类方法。这个问题很普遍，父类是否可以调用子类的方法呢，答案是可以，但是强烈不建议这么做，那应该怎么做呢

·把子类传递到父类的有参构造中，然后调用

·使用反射调用，使用了反射还有谁不能调用的

·父类调用子类的静态方法

   这三种都是父类直接调用子类方法的。我没有搞懂为什么要用父类调用子类的方法。如果一定要调用子类的，为什么不继承他呢。其实这个问题可以换角度去理解，父类建立框架，子类在重写了父类的部分方法后，在调用父类继承的方法，产生不同的结果，这正是模板方法，这是不是可以理解为父类调用子类的方法呢？你修改了子类，影响了父类行为的结果，曲线救国的方式实现了父类依赖子类的场景，模板方法就是这种效果。