常用设计模式

关注
发布于: 2020 年 09 月 22 日
本周讲解了Flower反应式编程框架的概念、思路及核心模块设计；
同时讲解了常用的设计模式，本篇总结了常用的11种设计模式
﻿
1       反应式编程框架Flower面临的问题：
﻿
﻿
使用Flower框架可以显著提升系统性能：
﻿
﻿
Flower实现异步的基础是使用Akka的Actor：
﻿
﻿
Flower核心模块设计：
﻿
﻿
Flower的分布式异步微服务解决方案:
﻿
﻿
2       设计模式设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码
设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
 
2.1     设计模式概述总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
 
用一个图片来整体描述一下：
﻿
﻿
2.2     单例模式（Singleton）单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。
 
在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。
 
单例模式有 3 个特点：
单例类只有一个实例对象；
该单例对象必须由单例类自行创建；
单例类对外提供一个访问该单例的全局访问点；
 
单例模式是设计模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。
 
单例模式的主要角色如下：
单例类：包含一个实例且能自行创建这个实例的类。
访问类：使用单例的类。
﻿
﻿
2.2.1      饿汉单例模式﻿
/**
 * 单例类
 */
public class SingleObject {
    //创建 SingleObject 的一个对象
    private static SingleObject instance = new SingleObject();
﻿
    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}
﻿
    //获取唯一可用的对象
    public static SingleObject getInstance(){
        return instance;
    }
﻿
    public void showMessage(){
        System.out.println("Hello Eager!");
    }
}
﻿
﻿
/**
 * 饿汉单例模式 测试
 */
public class SingletonPatternDemo {
    public static void main(String[] args) {
        //获取唯一可用的对象
        SingleObject object = SingleObject.getInstance();
﻿
        SingleObject object2 = SingleObject.getInstance();
﻿
        System.out.println(object == object2);
﻿
        //显示消息
        object.showMessage();
    }
}
﻿
﻿
2.2.2      懒汉单例模式
/**
 * 单例类
 */
public class SingleObject {
﻿
    private static SingleObject instance = null;
﻿
    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}
/*
    //获取唯一可用的对象（无线程安全问题，但大部分耗时浪费在synchronized修饰符的同步准备上，因此从性能上来说很不划算）
    public synchronized static SingleObject getInstance(){
        if (instance == null){
            instance = new SingleObject();
        }
        return instance;
    }
﻿
*/
    //这种写法同上面的没本质区别，存在性能问题。
    public static SingleObject getInstance(){
        synchronized (SingleObject.class) {
            if (instance == null) {
                instance = new SingleObject();
            }
        }
        return instance;
    }
﻿
    public void showMessage(){
        System.out.println("Hello Lazy!");
    }
}
﻿
﻿
/**
 * 懒汉单例模式 测试
 */
public class SingletonPatternDemo {
    public static void main(String[] args) {
        //获取唯一可用的对象
        SingleObject object = SingleObject.getInstance();
﻿
        SingleObject object2 = SingleObject.getInstance();
﻿
        System.out.println(object == object2);
﻿
        //显示消息
        object.showMessage();
    }
}
﻿
﻿
﻿
2.2.3      DCL双检琐单例模式(Double Check Lock)
/**
 * 单例类
 */
public class SingleObject {
﻿
    private volatile  static SingleObject instance = null;
﻿
    //让构造函数为 private，这样该类就不会被实例化
    private SingleObject(){}
﻿
﻿
    public static SingleObject getInstance(){
﻿
        if (instance == null) {
            synchronized (SingleObject.class) {
                if (instance == null) {
                    instance = new SingleObject();
                }
            }
        }
﻿
        return instance;
    }
﻿
    public void showMessage(){
        System.out.println("Hello DCL!");
    }
}
﻿
﻿
/**
 * DCL双检锁单例模式 测试
 */
public class SingletonPatternDemo {
    public static void main(String[] args) {
        //获取唯一可用的对象
        SingleObject object = SingleObject.getInstance();
﻿
        SingleObject object2 = SingleObject.getInstance();
﻿
        System.out.println(object == object2);
﻿
        //显示消息
        object.showMessage();
    }
}
﻿
﻿
2.2.4      静态内部类单例模式
/**
 * 单例类
 */
public class SingleObject {
﻿
    private static class SingletonHolder {
        private static final SingleObject INSTANCE = new SingleObject();
    }
﻿
    private SingleObject (){}
﻿
    public static final SingleObject getInstance() {
        return SingletonHolder.INSTANCE;
    }
﻿
    public void showMessage(){
        System.out.println("Hello Register!");
    }
}
﻿
﻿
/**
 * 静态内部类单例模式 测试
 */
public class SingletonPatternDemo {
    public static void main(String[] args) {
        //获取唯一可用的对象
        SingleObject object = SingleObject.getInstance();
﻿
        SingleObject object2 = SingleObject.getInstance();
﻿
        System.out.println(object == object2);
﻿
        //显示消息
        object.showMessage();
    }
}
﻿
﻿
﻿
2.2.5      枚举实现单例模式在effective java书中说道，最佳的单例实现模式就是枚举模式。利用枚举的特性，让JVM来帮我们保证线程安全和单一实例的问题。除此之外，写法还特别简单。
 
注：其他单例模式存在反射攻击或者反序列化攻击，枚举则可以有效避免。
/**
 * 单例类
 */
public enum SingleObject {
﻿
    INSTANCE;
﻿
    public void showMessage() {
        System.out.println("Hello Enum !");
    }
﻿
}
﻿
﻿
/**
 * 枚举单例模式 测试
 */
public class SingletonPatternDemo {
    public static void main(String[] args) {
        //获取唯一可用的对象
        SingleObject object = SingleObject.INSTANCE;
﻿
        SingleObject object2 = SingleObject.INSTANCE;
﻿
        System.out.println(object == object2);
﻿
        //显示消息
        object.showMessage();
    }
}
﻿
﻿
2.3     工厂方法模式（Factory Method）工厂方法（Factory Method）模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。
 
我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”。
 
工厂方法模式的主要优点有：
用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；
 
其缺点是：每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。
 
工厂方法模式由抽象工厂、具体工厂、抽象产品和具体产品等4个要素构成。本节来分析其基本结构和实现方法。
 
工厂方法模式的主要角色如下：
抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。
2.3.1      简单工厂模式如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”，它的缺点是增加新产品时会违背“开闭原则”。简单工厂模式可以看作是工厂方法模式的一个特例。
﻿
﻿
2.3.2      工厂方法模式“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
﻿
﻿
2.4     抽象工厂模式（Abstract Factory）抽象工厂（Abstract Factory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
 
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。
 
使用抽象工厂模式一般要满足以下条件：
系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。
 
抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下：
可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当增加一个新的产品族时不需要修改原代码，满足开闭原则。
 
其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。
 
抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构和实现方法。
 
抽象工厂模式的主要角色如下：
抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（Concrete Product）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它 同具体工厂之间是多对一的关系。
﻿
﻿
﻿
2.5     组合模式（Composite）组合（Composite）模式的定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。
 
组合模式的主要优点有：
组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；
 
其主要缺点是：
设计较复杂，客户端需要花更多时间理清类之间的层次关系；
不容易限制容器中的构件；
不容易用继承的方法来增加构件的新功能；
 
组合模式包含以下主要角色：
抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。
树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于实现抽象构件角色中 声明的公共接口。
树枝构件（Composite）角色：是组合中的分支节点对象，它有子节点。它实现了抽象构件角色中声明的接口，它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。
 
组合模式分为透明式的组合模式和安全式的组合模式：(1) 透明式：在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。
﻿
﻿
(2) 安全式：在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。
﻿
﻿
2.6     代理模式（Proxy）代理模式（Proxy）的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。
 
代理模式的主要优点有：
代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
代理对象可以扩展目标对象的功能；
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；
 
其主要缺点是：
在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
增加了系统的复杂度；
 
代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问，下面来分析其基本结构和实现方法。
 
代理模式的主要角色如下：
抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。
﻿
﻿
2.7     适配器模式（Adapter）适配器模式（Adapter）的定义如下：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。
 
该模式的主要优点如下：
客户端通过适配器可以透明地调用目标接口。
复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。
将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。
 
其缺点是：对类适配器来说，更换适配器的实现过程比较复杂。
 
类适配器模式可采用多重继承方式实现，如 C++ 可定义一个适配器类来同时继承当前系统的业务接口和现有组件库中已经存在的组件接口；Java 不支持多继承，但可以定义一个适配器类来实现当前系统的业务接口，同时又继承现有组件库中已经存在的组件。
 
对象适配器模式可釆用将现有组件库中已经实现的组件引入适配器类中，该类同时实现当前系统的业务接口。现在来介绍它们的基本结构。
 
适配器模式（Adapter）包含以下主要角色：
目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。
 
适配器模式可分为类适配器模式和对象适配器模式：
﻿
﻿
﻿
2.8     装饰模式（Decorator）装饰（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
 
装饰（Decorator）模式的主要优点有：
采用装饰模式扩展对象的功能比采用继承方式更加灵活。
可以设计出多个不同的具体装饰类，创造出多个不同行为的组合。
 
其主要缺点是：装饰模式增加了许多子类，如果过度使用会使程序变得很复杂。
 
通常情况下，扩展一个类的功能会使用继承方式来实现。但继承具有静态特征，耦合度高，并且随着扩展功能的增多，子类会很膨胀。如果使用组合关系来创建一个包装对象（即装饰对象）来包裹真实对象，并在保持真实对象的类结构不变的前提下，为其提供额外的功能，这就是装饰模式的目标。下面来分析其基本结构和实现方法。
 
装饰模式主要包含以下角色：
抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。
抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
具体装饰（Concrete Decorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。
 
﻿
2.9     外观模式（Facade）外观（Facade）模式的定义：是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。
 
外观（Facade）模式是“迪米特法则”的典型应用，它有以下主要优点：
降低了子系统与客户端之间的耦合度，使得子系统的变化不会影响调用它的客户类。
对客户屏蔽了子系统组件，减少了客户处理的对象数目，并使得子系统使用起来更加容易。
降低了大型软件系统中的编译依赖性，简化了系统在不同平台之间的移植过程，因为编译一个子系统不会影响其他的子系统，也不会影响外观对象。
 
外观（Facade）模式的主要缺点如下：
不能很好地限制客户使用子系统类。
增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”。
 
外观（Facade）模式的结构比较简单，主要是定义了一个高层接口。它包含了对各个子系统的引用，客户端可以通过它访问各个子系统的功能。现在来分析其基本结构和实现方法。
 
外观（Facade）模式包含以下主要角色：
外观（Facade）角色：为多个子系统对外提供一个共同的接口。
子系统（Sub System）角色：实现系统的部分功能，客户可以通过外观角色访问它。
客户（Client）角色：通过一个外观角色访问各个子系统的功能。
﻿
2.10   观察者模式（Observer）观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。
 
观察者模式是一种对象行为型模式，
其主要优点如下：
降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。
目标与观察者之间建立了一套触发机制。
 
它的主要缺点如下：
目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
 
实现观察者模式时要注意具体目标对象和具体观察者对象之间不能直接调用，否则将使两者之间紧密耦合起来，这违反了面向对象的设计原则。
 
观察者模式的主要角色如下：
抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。
﻿
﻿
2.11   策略模式（Strategy）策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。
 
策略模式的主要优点如下：
多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句。
策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。
策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。
策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。
策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。
 
其主要缺点如下：
客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
策略模式造成很多的策略类。
 
策略模式是准备一组算法，并将这组算法封装到一系列的策略类里面，作为一个抽象策略类的子类。策略模式的重心不是如何实现算法，而是如何组织这些算法，从而让程序结构更加灵活，具有更好的维护性和扩展性，现在我们来分析其基本结构和实现方法。
 
策略模式的主要角色如下：
抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
环境（Context）类：持有一个策略类的引用，最终给客户端调用。
﻿
﻿
代码示例：
/**
 * 抽象策略角色
 */
public interface Strategy {
    public int doOperation(int num1, int num2);
}
﻿
﻿
/**
 * 具体策略角色1 
 */
public class OperationAdd implements Strategy{
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}
﻿
﻿
/**
 * 具体策略角色2 
 */
public class OperationDivision implements Strategy{
    @Override
    public int doOperation(int num1, int num2) {
        return num1 / num2;
    }
}
﻿
﻿
/**
 * 环境角色
 */
public class Context {
    private Strategy strategy;
﻿
    public void setStrategy(Strategy strategy){
        this.strategy = strategy;
    }
﻿
    public int executeStrategy(int num1, int num2){
        return strategy.doOperation(num1, num2);
    }
﻿
}
﻿
﻿
/**
 * 策略模式 测试
 */
public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context();
﻿
        context.setStrategy(new OperationAdd());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
﻿
        context.setStrategy(new OperationDivision());
        System.out.println("10 / 5 = " + context.executeStrategy(10, 5));
    }
}
﻿
﻿
﻿
2.12   模板方法模式（Template Method）模板方法（Template Method）模式的定义如下：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。它是一种类行为型模式。
 
该模式的主要优点如下：
它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
它在父类中提取了公共的部分代码，便于代码复用。
部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。
 
该模式的主要缺点如下：
对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。
父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。
 
模板方法模式需要注意抽象类与具体子类之间的协作。它用到了虚函数的多态性技术以及“不用调用我，让我来调用你”的反向控制技术。现在来介绍它们的基本结构。
 
模板方法模式包含以下主要角色：
 
(1) 抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。
 
① 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。
 
② 基本方法：是整个算法中的一个步骤，包含以下几种类型。
抽象方法：在抽象类中申明，由具体子类实现。
具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。
 
(2) 具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。
﻿
参考：
https://xie.infoq.cn/article/e1ad7516ea89edc8257fddd94
﻿