模板方法模式

约定不等于承诺〃 2022-05-06 10:38 70阅读 0赞

## 引入一个例子 ##

![在这里插入图片描述][70]  
比如冲咖啡和冲茶两个过程，加工方法似乎都差不多。可以看成如下过程：  
把水煮沸boil()->冲泡brew()->倒进杯子里pourInCup()->加入调料addCondiments（)  
这就是可以作为模板方法，由他执行冲茶或者冲咖啡任务  
接下来介绍以下模板方法模式

## 模板方法模式 ##

模板方法模式将不变的算法部分封装到抽象类里的具体方法(final)中，将可变的实现部分交给子类，子类不能调用父类，只能向父类提供具体实现，交由父类控制。看下定义

### 定义 ###

在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类  
可以在不改变算法的结构的情况下，重新定义算法中的某些步骤。

### 优点 ###

1.  任何设计模式的最终目的—降低了系统的耦合
2.  模板方法模式其实是代码复用技术的一种
3.  模板方法模式导致一种反向的控制结构，通过一个父类调用其子类的操作，通过对子类的扩展增加新的行为，符合“开闭原则”。

### 缺点 ###

增加了系统中的类的数量（其实也并不是那么多，几个类才需要一个抽象父类）

### 实现 ###

CaffeineBeverage类

package 设计模式.模板方法模式;
    
    /**
     * Created by Administrator on 2018/10/13.
     */
    public abstract class CaffeineBeverage {
        final void preparerecipe(){
            boilWater();
            brew();
            pourInCup();
            if(customerWantCondiments()){
                addCondiments();
            }
        }
    
        private void boilWater(){
            //煮沸水
            System.out.println("Boiling water");
        }
    
        private void pourInCup(){
            //倒进杯子里
            System.out.println("Pouring into cup");
        }
    
        private boolean customerWantCondiments(){
            //客户是否想加调料，子类可以选择覆盖，默认true
            return true;
        }
        //天加调料
        abstract void addCondiments();
        //冲泡
        abstract void brew();
    }

coffee 类

package 设计模式.模板方法模式;
    
    /**
     * Created by Administrator on 2018/10/13.
     */
    public class coffee extends CaffeineBeverage{
        @Override
        void addCondiments() {
            System.out.println("Add sugar and milk");
        }
    
        @Override
        void brew() {
            System.out.println("Coffee is brew");
        }
    }

tea 类

package 设计模式.模板方法模式;
    
    /**
     * Created by Administrator on 2018/10/13.
     */
    public class tea extends CaffeineBeverage{
        @Override
        void addCondiments() {
            System.out.println("Add tea");
        }
    
        @Override
        void brew() {
            System.out.println("Tea is brew");
        }
    }

package 设计模式.模板方法模式;
    
    /**
     * Created by Administrator on 2018/10/13.
     */
    public class test {
        public static void main(String[] args){
            coffee c=new coffee();
            tea t=new tea();
            c.preparerecipe();
            t.preparerecipe();
        }
    }

![在这里插入图片描述][70 1]  
抽象类可以有不实现的方法，可以让子类覆盖，比如这里的CaffeineBeverage类里的 customerWantCondiments()

### 好莱坞原则 ###

*别调用我们，我们会调用你*  
高层组件对待底层组件的方式是“别调用我们，我们会调用你”，是为了避免  
组件之间的环形依赖，造成很难发觉的bug或者造成高耦合。  
这里让抽象类决定何时让子类参与进来，而不让子类调用父类的方法就是处于这层考虑  
典型的应用还有工厂模式，观察者，等等

## 总结 ##

1.  抽象方法的数量要适中。
2.  依赖倒置原则多用抽象类
3.  模板方法模式和策略模式有点相似

参考博客：[https://blog.csdn.net/chenssy/article/details/9634521][https_blog.csdn.net_chenssy_article_details_9634521]  
参考书籍：HeadFirst设计模式

[70]: /images/20220506/2e61891410a34ec4bc441b82638527b3.png
[70 1]: /images/20220506/c7ec8d5a0b7b43a5947141eb77d8abb0.png
[https_blog.csdn.net_chenssy_article_details_9634521]: https://blog.csdn.net/chenssy/article/details/9634521