【设计模式】模版方法模式(行为型)

模板方法模式

   定义一个操作中的算法的骨架。而将一些步走延迟到子类中。模板方法可以师子类不改变算法的结构。重定义算法的某些特定步走。

模型图

 代码

public  abstract class AbstractClass {
   public long TemplateMethod(){
		long A=primitiveMethod1();
		long B=primitiveMethod2();
		return A+B;
   }

   protected abstract long primitiveMethod1();
   protected abstract long primitiveMethod2();
}

 

 

public class ConcreteClass extends AbstractClass{

	@Override
	protected long primitiveMethod1() {
		// TODO Auto-generated method stub
		return 10;
	}

	@Override
	protected long primitiveMethod2() {
		// TODO Auto-generated method stub
		return 20;
	}

}

public class Test {
	public static void main(String[] args) {
		AbstractClass abstractClass=new ConcreteClass();
		long templateMethod = abstractClass.TemplateMethod();
		System.out.println(templateMethod);
	}
}

结果

案例

需求 写一个加载消息，对消息进行处理之后做远程发送的框架，要求可以通过xml格式发送，json格式发送，或者更多的格式

分析与设计 这个需求中有需要对消息做相同的加载操作，并对消息做相同的加工，然后通过不通的方式进行发送。综合这个需求

我们可以通过模板方法模式来实现相同的加载，加工。然后通过模板方法把不同的消息格式交给子类

模型

代码

package xiao.it.designer.decorator.templatemethod.instance;

import java.io.IOException;
import java.io.InputStream;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public abstract class AbstractMsg {

	/**
	 * 
	 * @Title: LoadMsg   
	 * @Description: (加载消息)   
	 * @param: @return
	 * @param: @throws IOException      
	 * @return: String
	 * @author xiaozhengwen      
	 * @throws
	 */
	private String LoadMsg() throws IOException{
	    Properties config=new Properties();
    	Object object = config.get("yy");
    	if(null!=object){
    		return object.toString();
    	}
    	return "演示";	
    }
	
	/**
	 * 
	 * @Title: sendMsg   
	 * @Description: (实际发送消息的类)   
	 * @param: @throws IOException      
	 * @return: void
	 * @author xiaozhengwen      
	 * @throws
	 */
	public void sendMsg() throws IOException{
		String loadMsg = LoadMsg();
		List<String> list=new ArrayList<String>();
		String format = MessageFormat.format(loadMsg, list);
		send(format);
	}
	
	/**
	 * 
	 * @Title: send   
	 * @Description: (模板方法)   
	 * @param: @param string      
	 * @return: void
	 * @author xiaozhengwen      
	 * @throws
	 */
	protected abstract void send(String string);
}

public class XmlSenderClassA  extends AbstractMsg{
	@Override
	protected void send(String string) {
		System.out.println("XmlSenderClassA:="+string);
	}
}

 

public class JSONSenderClassB extends AbstractMsg {
	@Override
	protected void send(String string) {
		System.out.println("JSONSenderClassB:="+string);
	}
}

 

public class Test {
    public static void main(String[] args) throws IOException {
		AbstractMsg abstractMsg=new XmlSenderClassA();
		abstractMsg.sendMsg();
		AbstractMsg abstractMsg2=new JSONSenderClassB();
		abstractMsg2.sendMsg();
	}
}

 

 

 小结

1   继承的目的就在于可以使用子类中重复的代码上升到父类中去，师父类成为子类的骨架

2  当我们完成一个层次细致的代码段，除个代码段有所不同，其他都相同的时候，我们就可以考虑模板方法模式

3  模板方法模式提供了一个很好的代码复用平台

4 当子类中变与不变的行为，混杂在一起的时候，为避免不变的行为重复出现，可以考虑把不变的行为搬移到父类中去