设计模式-创建型模式-模板方法

定义一个操作中的算法框架，将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义一个算法的步骤。

protected 对于本包及其子类可见。

类图

代码

代码如下

public abstract class AbstractClass{
    // 基本方法
    protected abstract void doSomething();    // 对于本包及其子类可见
    protected abstract void doAngthing();
    
    public void templateMethod(){
        this.doAngthing();
        this.doSomething();
    }
}

public class ConcreteClass1 extends AbstractClass {
    // 基本方法
    protected void doAnything(){
        
    }
    protected void doSomething(){
        
    }
}

public class ConcreteClass2 extends AbstractClass {
    // 基本方法
    protected void doAnything(){
        
    }
    protected void doSomething(){
        
    }
}

最后场景类完成调用。

public class Client{
    ConcreteClass1 class1 = ConcreteClass1();
    ConcreteClass1 class2 = ConcreteClass1();
    
    // 调用模板方法
    class1.templateMethod();
    class2.templateMethod();
}

扩展

public abstract class HummerModel{
    // 能发动
    protected abstract void start();
    // 能停下来
    protected abstract void stop();
    // 会发出声响
    protected abstract void alarm();
    // 引擎会响
    protected abstract void engineBoom();
    // 模型会跑
    public final void run(){
        // 发动汽车
        this.start();
        // 引擎轰鸣
        this.engineBoom();
        // 根据钩子，判断是否叫
        if (this.isAlarm()){
            this.alarm();
        }
        // 停车
        this.stop();
    }
    // 钩子
    protected boolean isAlarm(){
        return true;
    }
}

然后扩展HummerH1Model

public class HummerH1Model extends HummerModel{
    private boolean alamFlag = true;    // 默认会响
    protected void alarm(){
    }
    protected void engineBoom(){
    }
    protected void start(){
    }
    protected void stop(){
    }
    protected boolean isAlarm(){
        return this.alarmFlag;
    }
    // 要不要响喇叭，由客户决定
    public void setAlarm(boolean isAlarm){
        this.alarmFlag = isAlarm;
    }
}

public class HummerH2Model extends HummerModel{
    private boolean alamFlag = true;    // 默认会响
    protected void alarm(){
    }
    protected void engineBoom(){
    }
    protected void start(){
    }
    protected void stop(){
    }
    protected boolean isAlarm(){
        return this.alarmFlag;
    }
    // 要不要响喇叭，由客户决定
    public void setAlarm(boolean isAlarm){
        this.alarmFlag = isAlarm;
    }
}

最后定义场景

public class Client{
    public static void main(String[] args){
        // 生成一个HummerH1Model
        HummerH1Model h1 = new HummerH1Model();
        // 然后设置喇叭
        h1.setAlarm(false);
        // 启动
        h1.run();
        // 模型2
        HummerH2Model h2 = new HummerH2Model();
        h2.run();
    }
}

总结

上方使用了一个钩子方法，即Hook Method 由一个钩子，控制了整个的运行，灰常方便。
关于父类调用子类，不建议这样做，使用如下做
把子类传递到父类的有参的构造函数中，然后调用
使用反射调用
父类调用子类的静态方法。
总结：父类建立框架，子类重写父类的部分方法，再调用从父类继承而来的结果，此为模板方法。
或者，当提供提供抽象类，并有一堆子类，需要扩展的时候，继承抽象类，覆写protected方法，然后调用execute方法，完成扩展。即可。

ts

ts没有多少类似的，故不再阐述。