设计模式学习之模板方法模式

模板方法模式

定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。它是一基于继承的代码复用技术，是类行为型模式

类图

实现

抽象类

定义了一系列基本操作，这些基本操作可以是具体的，也可以是抽象的，每一个基本操作对应算法的一个步骤，在其子类中可以重定义或实现这些步骤。同时在抽象类中实现了一个模板方法，用于定义一个算法框架，模板方法不仅可以调用在抽象类中实现的基本方法，也可以调用在抽象类的子类中实现的基本方法，还可以调用其他对象中的方法

package design.templatemethod.realize;

/*
 *
 *@author:zzf
 *@time:2020-12-21
 *
 */
public abstract class AbstractClass {
    
    
    //模板方法
    public void templateMethod(){
    
    
        
    }
    
    //基本方法——具体方法
    public void primitiveOperation1(){
    
    
        
    }
    //基本方法——抽象方法
    public abstract void primitiveOperation2();
    
    //基本方法——钩子方法
    public void primitiveOperation3(){
    
    
        
    }
}

具体子类

package design.templatemethod.realize;

/*
 *
 *@author:zzf
 *@time:2020-12-21
 *
 */
public class ConcreteClass extends AbstractClass {
    
    
    @Override
    public void primitiveOperation2() {
    
    
        //实现
    }

    @Override
    public void primitiveOperation3() {
    
    
        //实现
    }
}

应用实例

某软件公司要为某银行的业务支撑系统开发一个利息计算模块，利息的计算流程如下：
(1) 系统根据账号和密码验证用户信息，如果用户信息错误，则系统显示出错提示。
(2) 如果用户信息正确，则根据用户类型的不同使用不同的利息计算公式计算利息（如活期账户和定期账户具有不同的利息计算公式）。
(3) 系统显示利息。
现使用模板方法模式设计该利息计算模块。

代码实现

账户类，充当抽象类

package design.templatemethod;

public abstract class Accout {
    
    

	// 基本方法：具体方法
	public boolean validata(String account, String password) {
    
    
		System.out.println("账号：" + account);
		System.out.println("密码：" + password);
		if (account.equalsIgnoreCase("张无忌") && password.equalsIgnoreCase("123456")) {
    
    
			return true;
		} else {
    
    
			return false;
		}

	}

	// 基本方法：抽象方法
	public abstract void calculateInterst();

	// 基本方法：具体方法
	public void display() {
    
    
		System.out.println("显示利息！");
	}

	// 模板方法
	public void handle(String account, String password) {
    
    
		if (!validata(account, password)) {
    
    
			System.out.println("账户或密码错误！");
			return;
		}
		calculateInterst();
		display();
	}
}

具体子类

package design.templatemethod;

public class CurrentAccount extends Accout {
    
    

	// 覆盖父类抽象基本方法
	public void calculateInterst() {
    
    
		System.out.println("按活期利率计算利息！");

	}
}

package design.templatemethod;

public class SavingAccount extends Accout {
    
    

	@Override
	public void calculateInterst() {
    
    
		System.out.println("按定期利率计算利息！");

	}
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<config>
	<className>design.templatemethod.CurrentAccount</className>
</config>

工具类

package design.templatemethod;

import java.io.File;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class XMLUtil {
    
    

	public static Object getBean() {
    
    
		try {
    
    
			// 创建DOM文档对象
			DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder builder = dFactory.newDocumentBuilder();
			Document doc;
			doc = builder.parse(new File("src//design//templatemethod//config.xml"));
			// 获取包含类名的文本节点
			NodeList nl = doc.getElementsByTagName("className");
			Node classNode = nl.item(0).getFirstChild();
			String cName = classNode.getNodeValue();

			// 通过类名生成实例对象
			Class c = Class.forName(cName);
			Object obj = c.newInstance();
			return obj;
		} catch (Exception e) {
    
    
			e.printStackTrace();
			return null;
		}
	}
}

客户端

package design.templatemethod;

public class Client {
    
    

	public static void main(String[] args) {
    
    
		Accout accout;
		accout = (Accout) XMLUtil.getBean();
		accout.handle("张无忌", "123456");
	}
}

如果需要更换具体子类，只需修改配置文件，符合开闭原则
钩子方法

一个钩子方法有一个抽象类或具体类声明并实现，其子类可能会加以扩展。通常在父类中给出的实现是一个空实现，并以该空实现作为方法的默认实现。当然，钩子方法也可以提供一个非空的默认实现

在模板方法模式中钩子方法有两类，第一类钩子方法可以与一些具体步骤挂钩，以实现在不同条件下执行模板方法中的不同步骤，这类钩子方法的返回
类型通常是boolean类型，方法名一般为isXXX()，用于对某个条件进行判断，如果条件满足则执行某一步骤，否则将不执行

第二类钩子方法是实现体为空的具体方法，子类可以根据需要覆盖或继承这些钩子方法。与抽象方法相比，这类钩子方法的好处在于子类如果没有覆盖父类中定义的钩子方法，编译可以正常通过，但是如果没有覆盖父类中声明的抽象方法，编译会报错

钩子方法的使用

某软件公司要为销售管理系统提供一个数据图表显示功能，该功能的实现包括以下几个步骤：
（1）从数据源获取数据
（2）将数据转换为XML格式
（3）以某种图表方法显示XML格式的数据
该功能支持多种数据源和多种图表显示方式，但所有的图表显示操作都是基于XML格式的数据，因此可能需要对数据进行转换，如果从数据源获取的数据已经是XML数据则无需转换

代码实现

抽象父类

package design.templatemethod.hookmethod;

/*
 *
 *@author:zzf
 *@time:2020-12-21
 *
 */
public abstract class DataViewer {
    
    
    //抽象方法，获取数据
    public abstract void getData();
    //具体方法，转换数据
    public void convertData(){
    
    
        System.out.println("将数据转换成XML格式");
    }
    //抽象方法，显示数据
    public abstract void displayData();
    //钩子方法，判断是否为XML格式数据
    public boolean isNotXMLData(){
    
    
        return true;
    }
    //模板方法
    public void process(){
    
    
        getData();
        //如果不是XML格式的数据则进行数据转换
        if(isNotXMLData()){
    
    
            convertData();
        }
        displayData();
    }
}

具体子类

package design.templatemethod.hookmethod;

/*
 *
 *@author:zzf
 *@time:2020-12-21
 *
 */
public class XMLDataViewer extends DataViewer {
    
    
    @Override
    public void getData() {
    
    
        System.out.println("从XML文件中获取数据");
    }

    @Override
    public void displayData() {
    
    
        System.out.println("以柱状图显示数据");
    }

    //覆盖父类的钩子方法，返回false表示已经是XML格式数据，无需转换
    @Override
    public boolean isNotXMLData() {
    
    
        return false;
    }
}

客户端

package design.templatemethod.hookmethod;

/*
 *
 *@author:zzf
 *@time:2020-12-21
 *
 */
public class Client {
    
    
    public static void main(String[] args) {
    
    
        DataViewer dv;
        dv=new XMLDataViewer();
        dv.process();
    }
}

运行结果

模板方法模式优缺点

优点：
（1）在父类中形式化地定义一个算法，而由它的子类来实现细节的处理，在子类实现详细的处理算法时并不会改变算法中步骤的执行次序
（2）提取了类库中的公共行为，将公共行为放在父类中，而通过其子类来实现不同的行为
（3）可实现一种反向控制结构，且具有良好的扩展性，符合单一职责原则和开闭原则

缺点：
需要为每一个基本方法的不同实现提供一个子类，如果父类中可变的基本方法太多，将会导致类的个数增加，系统更加庞大，设计也更加抽象

适用环境

（1）一次性实现一个算法的不变部分，并将可变的行为留给子类来实现
（2）各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复
（3）需要通过子类来决定父类算法中的某个步骤是否执行，实现子类对父类的反向控制

参考
Java设计模式