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

}
}

优点

模板方法模式通过把不变的行为搬移到超类，去除了子类中的重复代码。

子类实现算法的某些细节，有助于算法的扩展。

通过一个父类调用子类实现的操作，通过子类扩展增加新的行为，符合“开放-封闭原则”。

缺点

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

适用场景

在某些类的算法中，用了相同的方法，造成代码的重复。

控制子类扩展，子类必须遵守算法规则。