【设计模式达摩院四】模板模式很棒

逃离我推掉我的手 2023-01-13 10:50 105阅读 0赞

## 场景 ##

定义算法的骨架，骨架中具体的步骤可以延迟到子类中实现。新的子类在不改变算法结构的前提下重新定义该算法的某些特定步骤。

## 核心 ##

业务的处理流程已经确定，但某个环节代码暂时不确定。可以采用模板模式，将该部分代码交给子类完成。即，父类中定义好处理步骤，具体实现延迟到子类中定义。

## 解释 ##

dont call me ,we will call you back

子类不能调用父类，父类调用子类，调用步骤已经在父类中写好了，完全由父类控制整个过程。

## 示例 ##

先看泡茶和泡咖啡的过程

public class Coffee {
        void prepareRecipe(){
            boilWater();
            breCoffeeGrinds();
            pourInCup();
            addSugarAndMilk();
        }
    
        public void boilWater(){
            System.out.println("Boiling water");
        }
        public void breCoffeeGrinds(){
            System.out.println("breCoffeeGrinds");
        }
        public void pourInCup(){
            System.out.println("pourInCup");
        }
        public void addSugarAndMilk(){
            System.out.println("addSugarAndMilk");
        }
    }

public class Tea {
        void prepareRecipe(){
    
            boilWater();
            steepTeaBag();
            addLemon();
            pourInCup();
        }
    
        public void boilWater(){
            System.out.println("Boiling water");
        }
        public void steepTeaBag(){
            System.out.println("SteepTeaBag");
        }
        public void addLemon(){
            System.out.println("addLemon");
        }
        public void pourInCup(){
            System.out.println("pourInCup");
        }
    }

能够看得到两者有步骤上的重合，能否为封装重复的部分呢

## 模板方法 ##

定义一个模板类，模板类封装了算法骨架，具体算法的实现部分由子类实现

1.  算法只存在于一个地方，保护了算法，容易修改。
2.  可以将代码最大复用
3.  在不改变算法结构的情况下，重新定义算法的某些步骤。

public abstract  class CaffeineBeverage {
    
        public void  prepareBeverage() {
            boilWater();
            brew();
            pourInCup();
            if(customerWantCondiments()){
                addCondiments();
            }
    
        }
    
        public void boilWater(){
            System.out.println("Boiling water");
        }
        public abstract void brew();
        public void pourInCup(){
            System.out.println("pourInCup");
        }
        public abstract void  addCondiments();
    
        /**
         * 钩子，子类可以覆盖该方法从而控制算法行为
         * @return
         */
        public boolean customerWantCondiments(){
            return true;
        }
    }

> 钩子的使用，如果你既不想完全重构父类算法，也不想完全使用。那么就使用钩子，控制算法部分实现。

public class Tea extends CaffeineBeverage {
    
        @Override
        public void brew() {
            System.out.println("brew teaBag");
        }
    
    
        @Override
        public void addCondiments() {
            System.out.println("add Lemon");
        }
    }
    
    public class Coffee extends CaffeineBeverage {
    
    
    
        @Override
        public void brew() {
            System.out.println("brew coffee");
        }
    
    
        @Override
        public void addCondiments() {
            System.out.println("add Suger and Milk");
        }
    
    }

## 模板模式VS策略模式 ##

如果说所有设计模式的本质都是多态的话，两者应该说是一样的。我们在使用上需要作出选择，所以需要对比下两者具体使用上的区别。

1.  模板方法定义的是算法骨架，部分算法由子类实现。策略模式定义的是算法本身，子类已经完全实现了算法。只是通过算法的组合来达到动态改变算法的目的。
2.  模板方法最大化复用代码，效率很高，策略模式依赖更弱。

如果使用时发现一个动作由多个算法实现，只是需要改变部分动作则使用模板方法。如果发现一个动作可能存在多个不同的实现，需要动态改变算法时则使用策略模式。