设计模式之模板方法-CSDN博客

本文链接：https://blog.csdn.net/AIGUO666666/article/details/103374569

模板模式作用：是指定义一个算法的骨架，并允许子类为一个或者多个步骤提供实现。模板方法使得子类可以在不改变算法结

构的情况下，重新定义算法的某些步骤，属于行为性设计模式。

模板方法适用于以下应用场景：

1、一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现。

2、各子类中公共的行为被提取出来并集中到一个公共的父类中，从而避免代码重复。

适用于比较流程化的操作：洗锅-》放食材-》添加调料-》出锅装盘-》端上餐桌

**设计原则概览**
设计原则	简称	解释说明	备注
开闭原则	（OCP）Open-Closed Principle,	对扩展开放，对修改关闭。
依赖倒置原则	（DIP）Dependence Inversion Principle	高层模块不应该依赖底层模块，二者都应该依赖其抽象。也就是说针对接口编程，不要针对实现编程，针对接口编程包括使用接口或抽象类，这样可以使得各个模块彼此独立，降低模块间的耦合性。而且在实现类中尽量不发生直接的依赖关系，依赖关系通过接口或抽象类产生。
单一职责原则	（SRP）Single Responsibility Principle	一个类、接口、方法只做一件事。
接口隔离原则	（ISP）Interface Segregation Principle,	尽量保证接口的纯洁性，客户端不应该依赖不需要的接口。胖接口会导致他们的客户程序之间产生不正常的并且有害的耦合关系.当一个客户程序要求该胖接口进行一个改动时,会影响到所有其他的客户程序.因此客户程序应该仅仅依赖他们实际需要调用的方法.
迪米特法则	（LoD）Law of Demeter 又叫做最少知识原则（LKP）Least Knowledge Principle,	又叫最少知道原则，一个类对其所依赖的类知道得越少越好。就是说,如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用,如果其中的一个类需要调用另一个类的某一个方法的话,可以通过第三者转发这个调用。
里氏替换原则	（LSP）Liskov Substitution Principle,	子类可以扩展父类的功能但不能改变父类原有的功能。一般而言,如果有两个具体类A,B有继承关系,那么一个最简单的修改方案是建立一个抽象类C,然后让类A和B成为抽象类C的子类.
合成复用原则	（CARP）Composite/Aggregate Reuse Principle,	尽量使用对象组合、聚合，而不使用继承关系达到代码复用的目的。

上代码：

package Template;

/**
 * 模板会有一个或者多个未现实方法，
 * 而且这几个未实现方法有固定的执行循序
 *
 *
 * 洗锅-》放食材-》添加调料-》出锅装盘-》端上餐桌
 */
public abstract class ChaoCaiTemplate {

    protected void creatMeiShi(){
        //洗锅
        this.xiGuo();
        //放食材
        this.fangShiCai();
        //放调料
        this.jiaTiaoLiao();
        //装盘
        this.zhuangPan();
        //上桌
        this.shangCai();

        //是否放辣椒
        if(needPepper()){
            this.jiaLaJiao();//加辣椒
        }
    }

    protected abstract void jiaLaJiao();


    //钩子方法，实现流程的微调
    // 是否放辣椒
    protected boolean needPepper(){return false;}

    final void shangCai() {
        System.out.println("上菜");
    }

    final void zhuangPan() {
        System.out.println("装盘");
    }

    final void jiaTiaoLiao() {
        System.out.println("加调料");
    }

    final void fangShiCai() {
        System.out.println("放食材");
    }

    final void xiGuo() {
        System.out.println("洗锅");
    }

}

package Template;

public class MaoXueWang extends ChaoCaiTemplate{
    @Override
    protected void jiaLaJiao() {
        System.out.println("毛血旺要多放辣椒");
    }
}

package Template;

public class TuDouSi extends ChaoCaiTemplate{

    private  boolean laJiao = false;

    public TuDouSi(boolean laJiao) {
        this.laJiao = laJiao;
    }

    @Override
    protected void jiaLaJiao() {
        System.out.println("土豆丝放辣椒");
    }

    @Override
    protected boolean needPepper() {
        return this.laJiao;
    }
}

package Template;

public class Test {
    public static void main(String[] args) {
        ChaoCaiTemplate maoXueWang = new MaoXueWang();
        maoXueWang.creatMeiShi();
        System.out.println("==================================");

        //此构造方法的参数就是给模板的钩子使用的，可以控制某些方法要不要执行
        ChaoCaiTemplate tds = new TuDouSi(false);
//        ChaoCaiTemplate tds = new TuDouSi(true);
        tds.creatMeiShi();
    }
}

优点：

1、利用模板方法将相同处理逻辑的代码放到抽象父类中，可以提高代码的复用性。

2、将不同的代码不同的子类中，通过对子类的扩展增加新的行为，提高代码的扩展性。

3、把不变的行为写在父类上，去除子类的重复代码，提供了一个很好的代码复用平台，

符合开闭原则。

缺点：

1、类数目的增加，每一个抽象类都需要一个子类来实现，这样导致类的个数增加。

2、类数量的增加，间接地增加了系统实现的复杂度。

3、继承关系自身缺点，如果父类添加新的抽象方法，所有子类都要改一遍。