设计模式（4）：模板方法模式

标签：设计模式   模板方法模式   

模板方法模式：

定义：

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

模板方法模式非常简单，仅仅使用了Java的继承机制，但它是一个应用非常广泛的模式。

在软件开发工程中，如果相同一段代码复制过两次，就需要对设计产生怀疑，架构师要明确地说明为什么相同的逻辑要出现两次或更多次。

模板方法模式的优点：

封装不变，扩展可变部分

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

行为有父类控制，子类实现。

缺点：

子类对父类产生了影响。

生产悍马车辆模型：

类图：

悍马车有两个型号：H1和H2。

抽象悍马接口：

abstract class HummerModel {
	// 启动
	public abstract void start();

	// 停下
	public abstract void stop();

	// 喇叭响
	public abstract void alarm();

	// 发动机响
	public abstract void engineBoom();

	// 跑起来
	public abstract void run();
}

两种类型的悍马：

// H1悍马模型
class HummerH1Model extends HummerModel {

	public void start() {
		System.out.println("启动起来了");
	}

	public void stop() {
		System.out.println("停下来了");
	}

	public void alarm() {
		System.out.println("喇叭响了");
	}

	public void engineBoom() {
		System.out.println("发动机发动");
	}

	public void run() {
		// 先发动汽车
		this.start();
		// 引擎发动
		this.engineBoom();
		// 喇叭响
		this.alarm();
		// 停车
		this.stop();
	}

}

// H2类型
class HummerH2Model extends HummerModel {

	public void start() {
		System.out.println("启动起来了");
	}

	public void stop() {
		System.out.println("停下来了");
	}

	public void alarm() {
		System.out.println("喇叭响了");
	}

	public void engineBoom() {
		System.out.println("发动机发动");
	}

	public void run() {
		// 先发动汽车
		this.start();
		// 引擎发动
		this.engineBoom();
		// 喇叭响
		this.alarm();
		// 停车
		this.stop();
	}
}

两个实现类中run方法中的代码是相同的，这个run方法的实现应该在抽象类中，而不是在实现类中。

修改之后是这样的：

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();
	}
}

// H1悍马模型
class HummerH1Model extends HummerModel {

	public void start() {
		System.out.println("悍马H1---->启动起来了");
	}

	public void stop() {
		System.out.println("悍马H1---->停下来了");
	}

	public void alarm() {
		System.out.println("悍马H1---->喇叭响了");
	}

	public void engineBoom() {
		System.out.println("悍马H1---->发动机发动");
	}
}

// H2类型
class HummerH2Model extends HummerModel {

	public void start() {
		System.out.println("悍马H2---->启动起来了");
	}

	public void stop() {
		System.out.println("悍马H2---->停下来了");
	}

	public void alarm() {
		System.out.println("悍马H2---->喇叭响了");
	}

	public void engineBoom() {
		System.out.println("悍马H2---->发动机发动");
	}
}

这时抽象类HummerModel类中的run方法叫做模板方法，其他的方法叫做基本方法。模板方法实现对基本方法的调度，完成固定的业务逻辑。

场景类：

public class Client {
	public static void main(String[] args) {
		HummerModel h1 = new HummerH1Model();
		h1.run();
		
		HummerModel h2 = new HummerH2Model();
		h2.run();
	}
}

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

模板方法模式的扩展：

H1型号的悍马喇叭想让它响就响，H2型号的喇叭不要有声音。

在抽象类中增加一个实现方法isAlarm，有各个类覆写该方法。

abstract class HummerModel {
	// 启动
	protected abstract void start();

	// 停下
	protected abstract void stop();

	// 喇叭响
	protected abstract void alarm();

	// 发动机响
	protected abstract void engineBoom();

	// 跑起来
	public void run() {
		// 先发动汽车
		this.start();
		// 引擎发动
		this.engineBoom();
		// 喇叭响
		if (this.isAlarm()) {
			this.alarm();
		}
		// 停车
		this.stop();
	}

	// 钩子方法,默认喇叭是会响的
	protected boolean isAlarm() {
		return true;
	}

}

// H1悍马模型
class HummerH1Model extends HummerModel {

	private boolean alarmFlag = true;

	protected void start() {
		System.out.println("悍马H1---->启动起来了");
	}

	protected void stop() {
		System.out.println("悍马H1---->停下来了");
	}

	protected void alarm() {
		System.out.println("悍马H1---->喇叭响了");
	}

	protected void engineBoom() {
		System.out.println("悍马H1---->发动机发动");
	}

	protected boolean isAlarm() {
		return this.alarmFlag;
	}

	public void setAlarm(boolean alarmFlag) {
		this.alarmFlag = alarmFlag;
	}

}

// H2类型
class HummerH2Model extends HummerModel {

	protected void start() {
		System.out.println("悍马H2---->启动起来了");
	}

	protected void stop() {
		System.out.println("悍马H2---->停下来了");
	}

	protected void alarm() {
		System.out.println("悍马H2---->喇叭响了");
	}

	protected void engineBoom() {
		System.out.println("悍马H2---->发动机发动");
	}

	protected boolean isAlarm() {
		return false;
	}
}

场景类：

public class Client {
	public static void main(String[] args) throws IOException {
		HummerModel h1 = new HummerH1Model();

		System.out.println("-------------H1型号悍马---------------");
		System.out.println("H1型号的悍马是否需要喇叭响？ 0-不需要           1-需要");
		String type = (new BufferedReader(new InputStreamReader(System.in))).readLine();
		if(type.equals("0")){
			((HummerH1Model) h1).setAlarm(false);
		}
		h1.run();

		System.out.println("-------H2型号的悍马----");
	
		HummerModel h2 = new HummerH2Model();
		h2.run();
	}
}

用户可以控制H1型号的车的喇叭，外界条件改变，影响到了模板方法的执行。

抽象类中的isAlarm方法叫做钩子方法。

设计模式（4）：模板方法模式

标签：设计模式   模板方法模式   

原文地址：http://blog.csdn.net/u013476556/article/details/47128815