设计模式_模板方法模式

一部分为具体方法一部分为需要子类实现的方法

实线为继承,泛化。
虚线为实现。

public class TemplateMethodPattern {
    public static void main(String[] args) {
        AbstractClass abstractClass = new ConcreteClass();
        abstractClass.TemplateMethod();
    }

}
// 抽象类
abstract class AbstractClass{
    // 模板方法
    public void TemplateMethod(){
        SpecificMethod();
        AbstractMethod01();
        AbstractMethod02();
    }
    // 具体方法
    public void SpecificMethod(){
        System.out.println("具体方法调用");
    }
    public abstract void AbstractMethod01();
    public abstract void AbstractMethod02();

}
class ConcreteClass extends AbstractClass{

    @Override
    public void AbstractMethod01() {
        System.out.println("抽象方法1的实现被调用...");
    }

    @Override
    public void AbstractMethod02() {
        System.out.println("抽象方法2的实现被调用...");
    }
}

扩展:

钩子模板方法
有一个小判断

public class HookTemplateMethod {
    public static void main(String[] args){
        HookAbstractClass hookAbstractClass = new HookConcreteClass();
        hookAbstractClass.TemplateMethod();
    }
}
abstract class HookAbstractClass{

    //模板方法
    public void TemplateMethod() {
        abstractMethod1();
        HookMethod1();
        if (HookMethod2()) {
            SpecificMethod();
        }
        abstractMethod2();
    }

    //具体方法
    public void SpecificMethod() {
        System.out.println("抽象类中的具体方法被调用...");
    }
    //钩子方法1
    public void HookMethod1() {
    }
    //钩子方法2
    public boolean HookMethod2() {
        return true;
    }
    //抽象方法1
    public abstract void abstractMethod1();
    //抽象方法2
    public abstract void abstractMethod2();
}

//含钩子方法的具体子类
class HookConcreteClass extends HookAbstractClass {
    public void abstractMethod1() {
        System.out.println("抽象方法1的实现被调用...");
    }
    public void abstractMethod2() {
        System.out.println("抽象方法2的实现被调用...");
    }
    public void HookMethod1() {
        System.out.println("钩子方法1被重写...");
    }
    public boolean HookMethod2() {
        return false;
    }
}