行为型模式-模板方法模式

　　行为型模式又可以分成以下四类：第一类：通过父类与子类的关系进行实现。第二类：两个类之间。第三类：类的状态。第四类：通过中间类

　　模板方法模式属于第一类，父类与子类的关系

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

　　模板类中可包含要实现的模板方法，还可以包含基本方法，基本方法分三类

　　(1) 抽象方法：一个抽象方法由抽象类声明、由其具体子类实现。在C#语言里一个抽象方法以abstract关键字标识。

(2) 具体方法：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。

(3) 钩子方法：一个钩子方法由一个抽象类或具体类声明并实现，而其子类可能会加以扩展。通常在父类中给出的实现是一个空实现（可使用virtual关键字将其定义为虚函数），并以该空实现作为方法的默认实现，当然钩子方法也可以提供一个非空的默认实现。在模板方法模式中，钩子方法有两类：第一类钩子方法可以与一些具体步骤“挂钩”，以实现在不同条件下执行模板方法中的不同步骤，这类钩子方法的返回类型通常是bool类型的，这类方法名一般为IsXXX()，用于对某个条件进行判断，如果条件满足则执行某一步骤，否则将不执行；还有一类钩子方法就是实现体为空的具体方法，子类可以根据需要覆盖或者继承这些钩子方法，与抽象方法相比，这类钩子方法的好处在于子类如果没有覆盖父类中定义的钩子方法，编译可以正常通过，但是如果没有覆盖父类中声明的抽象方法，编译将报错。

　　下面再来看运算的例子

    package behavior.pattern.extend.templatemethod;

public abstract class AbstractCalculator {
    /* main method */
    public final void mainCaculate(String exp)
    {
        int result = calculate(exp);
        if(isPrint())
            print(exp, result);
        other(result);
    }

    /* control method */
    protected boolean isPrint()
    {
        return true;
    }

    /* abstract steps */
    protected abstract int calculate(String exp);
    protected abstract void print(String exp, int result);
    protected abstract void other(int result);

    /* assistant method */
    public int[] split(String exp,String opt){
        String array[] = exp.split(opt);
        int arrayInt[] = new int[2];
        arrayInt[0] = Integer.parseInt(array[0]);
        arrayInt[1] = Integer.parseInt(array[1]);
        return arrayInt;
    }
}

package behavior.pattern.extend.templatemethod;

public class Minus extends AbstractCalculator {

    private boolean isPrint;

    public Minus(boolean isPrint) {
        this.isPrint = isPrint;
    }

    @Override
    public int calculate(String exp) {
        int[] split = split(exp, "-");
        return split[0] - split[1];
    }

    @Override
    protected void print(String exp, int result) {
        System.out.println("the minus result: " + exp + " = " + result);
    }

    @Override
    protected boolean isPrint() {
        return isPrint;
    }

    @Override
    protected void other(int result) {
        System.out.println("other...");
    }
}

package behavior.pattern.extend.templatemethod;

public class Plus extends AbstractCalculator {

    private boolean isPrint;
    @Override
    public int calculate(String exp) {
        int[] split = split(exp, "+");
        return split[0] - split[1];
    }

    @Override
    protected void print(String exp, int result) {
        System.out.println("the plus result: " + exp + " = " + result);
    }

    @Override
    protected boolean isPrint() {
        return isPrint;
    }

    @Override
    protected void other(int result) {
        System.out.println("other...");
    }
}

package behavior.pattern.extend.templatemethod;

public class Multiply extends AbstractCalculator {

    private boolean isPrint;

    public Multiply(boolean isPrint) {
        this.isPrint = isPrint;
    }

    @Override
    public int calculate(String exp) {
        int[] split = split(exp, "*");
        return split[0] - split[1];
    }

    @Override
    protected void print(String exp, int result) {
        System.out.println("the multiply result: " + exp + " = " + result);
    }

    @Override
    protected boolean isPrint() {
        return isPrint;
    }

    @Override
    protected void other(int result) {
        System.out.println("other...");
    }
}

　　测试代码

package behavior.pattern.extend.templatemethod;

public class Client {
    public static void main(String[] args) {
        AbstractCalculator minus = new Minus(true);
        minus.mainCaculate("43536363-1155145");
    }
}

　　运行结果

原文地址：https://www.cnblogs.com/liunianfeiyu/p/10122134.html