模板方法模式的升级

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

模板方法的类图比较简单，这里就不画出来了。有需要的可以上网Google一下。我们直接看例子。
现在需求要实现学生A与学生B做同一份试卷。
大量Ctrl C+Ctrl V

//学生A的试卷
public class TestPaperA {
	public void testQuestion1(){
		System.out.println("杨过得到，后来给了郭靖，炼成了倚天剑、屠龙刀的玄铁可能是[]");
		System.out.println("a.球魔铸铁 b.马口铁 c.高速合金钢 d.碳素纤维");
		System.out.println("答案是：A");
	}
	
	public void testQuestion2(){
		System.out.println("杨过、程英、陆无双铲除了情花，造成[]");
		System.out.println("a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化");
		System.out.println("答案是：B");
	}
}


//学生B的试卷
public class TestPaperB {	
		public void testQuestion1(){
			System.out.println("杨过得到，后来给了郭靖，炼成了倚天剑、屠龙刀的玄铁可能是[]");
			System.out.println("a.球魔铸铁 b.马口铁 c.高速合金钢 d.碳素纤维");
			System.out.println("答案是：C");
		}
		
		public void testQuestion2(){
			System.out.println("杨过、程英、陆无双铲除了情花，造成[]");
			System.out.println("a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化");
			System.out.println("答案是：C");
		}	
}


//客户端测试代码
public class Client {
     public static void main(String[] args) {
		System.out.println("学生A的试卷");
		TestPaperA studentA = new TestPaperA();
		studentA.testQuestion1();
		studentA.testQuestion2();
		
		System.out.println();
		System.out.println("学生B的试卷");
		TestPaperB studentB = new TestPaperB();
		studentB.testQuestion1();
		studentB.testQuestion2();
	}
}

结果显示：





很容易就发现，学生A试卷与学生B试卷的代码十分相似，除了答案不同，没什么不一样。大量的Ctrl+C与Ctrl+V只会给维护的时候带来难以预计的灾难。
可以通过继承能提取大量相同的代码，而使用模板方法就进一步上升了继承的高度：当我们要完成某一细节层次一致的一个过程或者一系列步骤，但个别步骤更详细的层次上的实现可能有不同时，我们通常会考虑用模板方法模式来处理。

上面做试卷的例子，学生A与学生B除了答案所有东西都一模一样，连题目的顺序也一样，因为我们可以把这些相同的东西通通抽取成一个模板。
使用模板方法模式

public abstract class TestPaper {
     
	public final void testQuestion1(){
		System.out.println("杨过得到，后来给了郭靖，炼成了倚天剑、屠龙刀的玄铁可能是[]");
		System.out.println("a.球魔铸铁 b.马口铁 c.高速合金钢 d.碳素纤维");
		System.out.println("答案是："+answer1());
	}

	public abstract String answer1();
	public abstract String answer2();
	
	public final void testQuestion2(){
		System.out.println("杨过、程英、陆无双铲除了情花，造成[]");
		System.out.println("a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化");
		System.out.println("答案是："+answer2());
	}
	
	public final void template(){
		testQuestion1();
		testQuestion2();
	}
}

学生A与学生B的试卷：

public class TestPaperA extends TestPaper{

	@Override
	public String answer1() {		
		return "A";
	}

	@Override
	public String answer2() {		
		return "B";
	}
}


public class TestPaperB extends TestPaper{

	@Override
	public String answer1() {		
		return "C";
	}

	@Override
	public String answer2() {
		return "C";
	}
}

客户端测试代码：

public class Client {
     public static void main(String[] args) {
		System.out.println("学生A的试卷");
		TestPaper a = new TestPaperA();
		a.template();
		
		System.out.println("=======================无敌分界线==========================");
		System.out.println("学生B的试卷");
		TestPaper b = new TestPaperB();
		b.template();
	}
}

经改造后，学生A与学生B的试卷变得十分简洁，只省下答案，因为只有答案是变化的。
其中一条设计原则是：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。简称提取公共的东西，封装变化的东西。
而模板方法模式把这些不变的行为搬到单一的地方，并定义好与变化的行为的步骤，这样就帮助子类摆脱重复的行为，又能实现相同的算法。


===============================================无敌分界线==============================================

通过研究Spring的HibernateTemplate源代码,可以发现HibernateTemplate也是借助了模板方法模式的思想。
在设计模式一书中对于模板模式GOF给出了用抽象类来实现，而spring却偏偏把它抽象到
了接口的层次。使其具有更高的扩展性，这就是一种创新的做法。
仿照Spring HibernateTemplate的思想，重新改造上面试卷的例子。

模板方法的升级
把变化的行为抽象成一个接口

public interface Answer {
       public String answer1();
       public String answer2();
}

模板不再是一个抽象类，而是一个具体类，因为已经不需要继承！而接口就作为参数传入模板的方法中

public class TestPaper {    
	public final void testQuestion1(Answer answer){
				
		System.out.println("杨过得到，后来给了郭靖，炼成了倚天剑、屠龙刀的玄铁可能是[]");
		System.out.println("a.球魔铸铁 b.马口铁 c.高速合金钢 d.碳素纤维");
		System.out.println("答案是："+answer.answer1());
	}
	
	public final void testQuestion2(Answer answer){
		System.out.println("杨过、程英、陆无双铲除了情花，造成[]");
		System.out.println("a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化");
		System.out.println("答案是："+answer.answer2());
	}
	
	public final void template(Answer answer){
		testQuestion1(answer);
		testQuestion2(answer);
	}	
}

注意：也可以用组合的方式代替传参数，至于模板选择哪种方式就取决于你的需求

public class TestPaper2 {
	
	private Answer answer;
	
	public TestPaper2(Answer answer){
		this.answer = answer;
	}
	
	private final void testQuestion1(){
		
		System.out.println("杨过得到，后来给了郭靖，炼成了倚天剑、屠龙刀的玄铁可能是[]");
		System.out.println("a.球魔铸铁 b.马口铁 c.高速合金钢 d.碳素纤维");
		System.out.println("答案是："+answer.answer1());
	}
	
	private final void testQuestion2(){
		System.out.println("杨过、程英、陆无双铲除了情花，造成[]");
		System.out.println("a.使这种植物不再害人 b.使一种珍稀物种灭绝 c.破坏了那个生物圈的生态平衡 d.造成该地区沙漠化");
		System.out.println("答案是："+answer.answer2());
	}
	
	public final void template(){
		testQuestion1();
		testQuestion2();
	}	
}

学生A与学生B只需要实现Answer接口(变化的部分)即可

public class TestPaperA implements Answer{

	public String answer1() {		
		return "A";
	}

	public String answer2() {		
		return "B";
	}
}


public class TestPaperB implements Answer{

	public String answer1() {		
		return "C";
	}

	public String answer2() {		
		return "C";
	}
}

客户端测试代码：

public class Client {
     public static void main(String[] args) {
		 TestPaper testPaper = new TestPaper();
    	 Answer a = new TestPaperA();
    	 System.out.println("学生A的考卷");
    	 testPaper.template(a);
		 
    	 System.out.println("=====================无敌分界线========================");
    	 System.out.println("学生Ｂ的考卷");
    	 Answer b = new TestPaperB();
    	 testPaper.template(b);
	}
}

显示结果：略
(第2种模板的测试代码略)

总结一下这种做法的优点：
1)由于Java不支持多重继承，所以采用模板方法时，子类继承模板会有诸多限制，而采用接口代替抽象类来封装变化，不但是一种创新的做法，而且使模板方法模式更加灵活，能适用于更多需求。
2)继承只能在编译时就决定(静态)，而采用委托的方式可以在运行时去改变行为(动态)
3)有时候子类会被调用得十分频繁，如果每调用一次就继承一个庞大的模板，这显然十分笨重。用接口代替抽象类配合模板方法，既达到了代码服用的效果，又能轻松实现某些特定步骤。