分析模板方法设计模式

首先来看看用来比较int和String分别进行1000次运算求需要的时间进行比较，代码的实现：

package com.test;

import java.util.Scanner;
//String的连接1000次
class StringOperate{
    private String str;
    public long doWork(){
        long begin=System.currentTimeMillis();//开始时间
        setStr(null);
        for(int i=0;i<10000;i++){
            setStr(getStr() + i);
        }
        long end=System.currentTimeMillis();//结束时间
        long time=end-begin;//时间差
        return time;
    }
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
}
class IntOperate{
    private int num=0;
    public long doWork(){
        long begin=System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            setNum(getNum() + i);
        }
        long end=System.currentTimeMillis();
        long time=end=begin;
        return time;
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
}
//模板方法设计模式
class TemplateMethosDemo{

}
public class Main{
    private static Scanner sc;

    public static void main(String[] args){
        //统计String连接10000次此时和int相加的时间差
        StringOperate st=new StringOperate();
        System.out.println(st.doWork());
        IntOperate in=new IntOperate();
        System.out.println(in.doWork());
    }
}

通过上述代码我们可以看出即使我们实现了上述的功能，但是代码不仅执行的效率低而且代码重复冗余，于是想到利用模板设计方法来实现：

package com.test;

import java.util.Scanner;
//模板方法设计模式
abstract class AbstractOperateTimeTemplate{
    //模板方法：总体算法的骨架,子类不能修改算法的结构因此用final
    final public long getTotalTime(){
        long begin=System.currentTimeMillis();//开始时间
        //具体操作(留给子类去完成),先调用子类中的再调用父类中的方法
        this.doWork();
        long end=System.currentTimeMillis();//结束时间
        long time=end-begin;
        return time;
    }
    //只能之类修改
    protected abstract void doWork();
}
//String的连接1000次
class StringOperate extends AbstractOperateTimeTemplate{
    public void doWork(){
        String str="";
        for(int i=0;i<10000;i++){
            str+=i;
        }
    }

}
class IntOperate extends AbstractOperateTimeTemplate{
    public void doWork(){
        int num=0;
        for(int i=0;i<1000000;i++){
            num+=i;
        }
    }
}

public class Main{
    public static void main(String[] args){
        //统计String连接10000次此时和int相加的时间差
        System.out.println(new StringOperate().getTotalTime());
        System.out.println(new IntOperate().getTotalTime());
    }
}

上述代码中doWork()也叫钩子函数（回调函数)。