模板方法设计模式

/**
 * 抽象模板角色
 */
public abstract  class AbstractTemplate {
    // 模板方法
    public void templateMethod(){
        abstractMethod01();
        abstractMethod02();
        if(booleanHook()){
            specificMethod();
        }
        hook();
    }
    /*抽象方法1*/
    protected abstract void abstractMethod01();
    /*抽象方法2*/
    protected abstract void abstractMethod02();
    /*具体方法*/
    protected void specificMethod() {
        System.out.println("没有重写的specificMethod方法");
    }
    /*空实现的钩子函数*/
    protected  void hook(){};
    /*判断用的钩子函数,默认返回false*/
    protected boolean booleanHook(){return false;}
}

/**
 * 具体模板角色，模板方法不需要重写，重写抽象方法，具体方法，钩子方法。判断用的钩子方法返回true；
 */
public class ConcreteTemplate extends AbstractTemplate {
    @Override
    protected void specificMethod() {
        System.out.println("重写 specificMethod方法");
    }

    @Override
    protected void hook() {
        System.out.println("重写hook方法");
    }

    @Override
    protected boolean booleanHook() {
        return true;
    }

    @Override
    protected void abstractMethod01() {
        System.out.println("重写 abstractMethod01方法");
    }

    @Override
    protected void abstractMethod02() {
        System.out.println("重写 abstractMethod02方法");
    }
}

/**
 * 具体模板角色,判断钩子方法返回ture,具体方法不重写。抽象方法，钩子方法重写，模板方法不重写
 */
public class ConcreteTemplate1 extends AbstractTemplate {


    @Override
    protected void hook() {
        System.out.println("重写hook方法");
    }

    @Override
    protected boolean booleanHook() {
        return true;
    }

    @Override
    protected void abstractMethod01() {
        System.out.println("重写 abstractMethod01方法");
    }

    @Override
    protected void abstractMethod02() {
        System.out.println("重写 abstractMethod02方法");
    }
}

**
 * 模式方法客户端类
 * 优点： 1、封装不变部分，扩展可变部分。
 * 2、提取公共代码，便于维护。
 * 3、行为由父类控制，子类实现。
 *
 缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。
 */
public class TemplateClient {
    public static void main(String[] args) {
        //创建具体模板类，抽象类具体方法重写
        AbstractTemplate template=new ConcreteTemplate();
        //调用模板方法也叫钩子函数
        template.templateMethod();
        //创建具体模板类，抽象类具体方法不重写
        AbstractTemplate template1=new ConcreteTemplate1();
        //调用模板方法也叫钩子函数
        template1.templateMethod();
    }
}

/**
 * 抽象模板类，做土豆丝类
 */
public abstract class CookingPotato {
    /**炒土豆丝的顺序*/
    public void cook(){
        oil();
        potato();
        salt();
        if(vinegarFlag()){
             vinegar();
        }

    }
    /*是否放醋*/
    protected boolean vinegarFlag() {
        return false;
    }
    /*放醋*/
    protected  void vinegar(){
        System.out.println("放入适当的醋");
    };
    /*放盐*/
    protected abstract void salt();
    /*放土地丝*/
    private void potato() {
        System.out.println("放入足量的土豆丝");
    }
    /*放油*/
    protected abstract void oil();

}

/**
 * 厨师做土豆丝
 */
public class Cooker extends CookingPotato{
    @Override
    protected boolean vinegarFlag() {
        return true;
    }

    @Override
    protected void salt() {
        System.out.println("放入适量的盐");
    }

    @Override
    protected void oil() {
        System.out.println("放入适量的油");
    }
}

/**
 * 普通人做土豆丝
 */
public class CommonPeople extends CookingPotato {
    @Override
    protected boolean vinegarFlag() {
        return false;
    }

    @Override
    protected void salt() {
        System.out.println("盐放多了。。。");
    }

    @Override
    protected void oil() {
        System.out.println("油放多了。。。");
    }
}

/**
 * 客户端
 */
public class ClientTest {
    public static void main(String[] args) {
        CookingPotato cooker=new Cooker();
        CookingPotato commonPeople=new CommonPeople();
        //厨师的cook方法
        cooker.cook();
        System.out.println("-------------------------------");
        //普通人的cook方法
        commonPeople.cook();
    }
}