Java常用GoF设计模式之一模板模式

模板模式中的方法
模板方法中的方法可以分为两大类：模板方法和基本方法。
　模板方法
　　●　一个模板方法是定义在抽象类中的，把基本操作方法组合在一起形成一个总算法或一个总行为的方法。
　　●　一个抽象类可以有任意多个模板方法，而不限于一个。每一个模板方法都可以调用任意多个具体方法。
　基本方法
　　基本方法又可以分为三种：抽象方法(Abstract Method)、具体方法(Concrete Method)和钩子方法(Hook Method)。
　　●　抽象方法：一个抽象方法由抽象类声明，由具体子类实现。在Java语言里抽象方法以abstract关键字标示。
　　●　具体方法：一个具体方法由抽象类声明并实现，而子类并不实现或置换。

　　●　钩子方法：一个钩子方法由抽象类声明并实现，而子类会加以扩展。通常抽象类给出的实现是一个空实现，作为方法的默认实现。

抽象的模版类：

package cn.gof.templete;
/**
 * @author zhaopan
 * @date 2016年10月21日 下午3:51:50
 * 模版模式适用于  
 *  泡茶：
 *  烧开水 ==> 冲泡茶叶 ==> 倒入杯中 ==> 倒水
 *  泡咖啡：
 *  烧开水 ==> 冲泡咖啡 ==> 倒入杯中 ==> 倒水
 *  
 *  或者银行业务：
 *  存款：
 *  拿号 ==> 叫号 ==> 取款 ==> 评价
 *  取款：
 *  拿号 ==> 叫号 ==> 取款 ==> 评价
 *  
 */
public abstract class Templete {

	//基本方法中的具体方法
	public void preMethod(){
		System.out.println("拿号");
	}
	//基本方法中的具体方法
	public void aftereMethod(){
		System.out.println("评价");
	}
	//基本方法中的具体方法
	public void middleMethod1(){
		System.out.println("叫号");
	};
	public abstract void middleMethod2();
	public void cascadeMethod(){
		preMethod();
		middleMethod1();
		middleMethod2();
		middleHookMethod();
		aftereMethod();
	}
	//钩子方法
	public void middleHookMethod() {
		// TODO Auto-generated method stub
		
	}
}

具体的实现类A：

package cn.gof.templete;
/**
 * @author zhaopan
 * @date 2016年10月21日 下午3:55:24
 * 存款
 */
public class SpecificA extends Templete {

	@Override
	public void middleMethod2() {
		System.out.println("存款");

	}
	public void middleHookMethod(){//实现自己具体的钩子方法
		System.out.println("查询余额");
	}

}

具体的实现类B：

package cn.gof.templete;
/**
 * @author zhaopan
 * @date 2016年10月21日 下午3:55:24
 * 取款
 */
public class SpecificB extends Templete {

	@Override
	public void middleMethod2() {
		System.out.println("取款");
	}

}

测试：

package cn.gof.templete;

import org.junit.Test;

/**
 * @author zhaopan
 * @date 2016年10月21日 下午4:05:18
 * 
 */
public class TempleteTest {

	@Test
	public void templeteTest(){
		SpecificA a=new SpecificA();
		SpecificB b=new SpecificB();
		a.cascadeMethod();
		b.cascadeMethod();
		
	}
}

优点
模板方法模式通过把不变的行为搬移到超类，去除了子类中的重复代码。
子类实现算法的某些细节，有助于算法的扩展。
通过一个父类调用子类实现的操作，通过子类扩展增加新的行为，符合“开放-封闭原则”。

缺点
每个不同的实现都需要定义一个子类，这会导致类的个数的增加，设计更加抽象。

适用场景
在某些类的算法中，用了相同的方法，造成代码的重复。
控制子类扩展，子类必须遵守算法规则。