抽象模板模式

**

模板方法模式

**
定义一个操作算法的骨架，将一些不住延迟到子类中；

• 抽象模板：
  定义一个抽象算法的骨架，将其他一些操作延迟加载到子类中
  定义多个抽象操作，以便让子类实现
  实现一个模板，作为子类公用
  定义钩子，做业务扩展牵引
• 具体模板
  实现父类定义的一个或多个抽象方法
  可以任意多个子类实现模板
  每个具体实现可以以不同方式实现模板方法

例子

实现生活中例子：
    冲coffee：
    烧水 ---》冲coffee ---》装杯 ---》添加牛奶
    泡茶：
    烧水 ---》泡茶 ---》装杯 ---》添加柠檬
模板类
/*
 * 抽象模板类
 */
public abstract class Beverage {

    /*
     * 模板方法，定义步骤,封装了所有子类将实现的算法框架
     * 模板方法不可改变
     */
    public final void makeTemlate(){
        /*
         * 烧水
         */
        System.out.println("step 1:");
        boilWater();
        /*
         * 泡制饮料
         */
        System.out.println("step 2:");
        brew();
        /*
         * 倒入杯中
         */
        System.out.println("step 3:");
        pourIn();
        /*
         * 添加佐料
         */
        if(isNeed()){
            System.out.println("step 4:");
            addCondiment();
        }
    }

    /*
     * 钩子方法，实现一个空或者默认方法
     * 具体子类可以根据业务定义如何挂钩
     */
    protected boolean isNeed() {
        return true;
    }
    /*
     * 烧水 ，基本方法
     * private 保证基本方法不会被覆盖
     */
    private void boilWater() {
        System.out.println("把水烧开");
    }
    /*
     * 制造饮料
     */
    protected abstract void brew();
    /*
     * 倒入杯中,基本方法
     * propected 保证能被子类继承的前提下还满足最少知道原则
     */
    protected void pourIn() {
        System.out.println("倒入杯中");
    }
    /*
     * 添加佐料
     */
    protected abstract void addCondiment();
}

coffee类
public class Coffee extends Beverage {

    @Override
    protected void addCondiment() {
        System.out.println("添加牛奶");
    }

    @Override
    protected void brew() {
        System.out.println("用水冲制coffee");
    }

    /*
     * 子类自定义的钩子方法，实现对业务的控制
     */
    @Override
    protected boolean isNeed(){
        return false;
    }
}
tea类
/*
 * 具体子类 ，实现茶的制作方式
 */
public class Tea extends Beverage {
    @Override
    protected void brew() {
        System.out.println("泡制茶水");
    }
    @Override
    protected void addCondiment() {
        System.out.println("加入柠檬");

    }
}

app使用
public class App {

    public static void main(String[] args) {
        System.out.println("开始制造咖啡...");
        Beverage coffee = new Coffee();
        coffee.makeTemlate();
        System.out.println("咖啡制造完成，请慢用！");

        System.out.println("--------------line----------------");

        System.out.println("开始制造茶...");
        Beverage Tea = new Tea();
        Tea.makeTemlate();
        System.out.println("茶制造完成，请慢用！");
    }
}
//结果如下
开始制造咖啡...
step 1:
把水烧开
step 2:
用水冲制coffee
step 3:
倒入杯中
咖啡制造完成，请慢用！
-------------------line-------------------
开始制造茶...
step 1:
把水烧开
step 2:
泡制茶水
step 3:
倒入杯中
step 4:
加入柠檬
茶制造完成，请慢用！

优点
1.复用性：模板方法模式通过把不变的行为搬移到超类，去除了子类中的重复代码。
2.屏蔽细节：子类实现算法的某些细节，模板中看不出具体实现。
3.封装性：通过一个父类调用子类实现的操作，通过子类扩展增加新的行为，符合“开放-封闭原则”。

缺点
1.每个不同的实现都需要定义一个子类，这会导致类的个数的增加，设计更加抽象，如果子类过多，会出现太多的类。
2.java只支持单继承，所以如果业务需要需要增加继续就很麻烦

适用场景
1.算法，操作相似的业务逻辑。
2.重构时发现相同的逻辑代码。
3.封装核心的算法

本文属于个人学习笔记，内容如有雷同，十分感谢大神分享0.0