• 设计模式解析之模板方法模式：设计灵活可扩展的算法框架

    目录

    1. 引言

        在软件开发中，设计和实现算法是一项常见的任务。然而，随着需求的变化和代码的增长，算法的复杂性往往会导致代码变得冗长、难以维护和重复编写。这时，模板方法模式就成为了一个解放程序员双手的利器。模版方法是一种常见的设计模式，它帮助我们定义一个算法的骨架，将具体实现交给子类去完成。本文将介绍模版方法的概念、应用场景以及如何使用，还会做一部分延申讲解。

    2. 概要

    2.1 概念

        模版方法是一种行为型设计模式，它定义了一个操作的算法骨架，具体步骤由子类实现。模版方法使得子类可以在不改变算法结构的情况下重新定义算法的某些步骤。

    概念剖析：

        行为型设计模式：是一种软件设计模式，它关注对象之间的交互和通信，以及如何将责任分配给不同的对象。行为型设计模式描述了对象之间的相互作用和通信方式，使得系统中的对象能够更好地协调合作。

        行为型设计模式解决了不同对象之间的交互问题，提供了一些常见的设计方案，以便开发人员在特定的情况下作出选择。这些模式强调对象之间的关系、算法的分配和职责的分离，从而增强了代码的灵活性、可维护性和可复用性。

        模板方法基于继承机制，让子类决定如何实现算法中的一些步骤，从而使得不同的子类可以有不同的行为。
    模板方法模式通过把不变部分的算法封装在父类中，而将变化部分的实现留给子类实现，从而提高了代码的复用性和可维护性。在模板方法模式中，父类决定了算法的执行顺序和一些通用步骤，而子类可以自行实现这些步骤的具体细节，以达到特定的效果。

        模板方法模式常用于框架设计中。框架中定义了一系列的算法骨架，具体算法的实现由各个子类来完成。这样，框架具有了很好的扩展性，可以轻松地添加新的算法或修改已有算法的实现，同时也使得框架内的代码更加稳定和可靠。

        总之，模板方法模式体现了一种抽象思想，即将具有相同的算法骨架的一组算法封装到一个抽象类中，并将一些具体的实现步骤留给子类去完成。由于其抽象性和灵活性，模板方法模式在面向对象软件开发中得到了广泛的应用。

        算法骨架：可以理解为算法的步骤。在模板方法设计模式中，抽象类定义了算法的整体结构和执行顺序，也就是算法的骨架，包括了一系列步骤或操作。这些步骤通常是按照特定的顺序进行执行，但具体的实现可能有所不同。

        模板方法中的算法骨架由抽象方法和具体方法组成。抽象方法是需要子类提供具体实现的步骤，而具体方法是已经实现的通用步骤或可以被子类重写的可选步骤。子类通过继承抽象类并实现其中的抽象方法，从而完成对算法骨架的填充，使得整个算法能够根据子类的实际需求得到具体执行。

        总之，算法骨架可以看作是算法的步骤和执行顺序的抽象描述，通过模板方法设计模式可以更好地实现算法的复用和扩展。

    2.2 结构

    模版方法模式包含以下几个角色：

        1、抽象类（Abstract Class）：定义了算法骨架和抽象方法，包含一系列的具体步骤，并且可以包含一些默认的实现，用于规范子类的行为。抽象类中可能还包含其他抽象方法或具体方法，这些方法可以被模板方法调用。

        2、具体类（Concrete Class）：具体类是抽象类的子类，负责实现在抽象类中定义的抽象方法，完成特定的具体步骤。具体类还可以覆盖抽象类中的钩子方法，以便在必要时对算法进行扩展或修改。

        3、钩子方法（Hook Method）：钩子方法是在抽象类中定义但没有具体实现的方法，它可以被具体类覆盖，用于控制算法的执行。钩子方法提供了一个扩展点，使得具体类可以在不修改模板方法的情况下，对算法进行个性化的定制。
        钩子方法通常在抽象类中被定义为虚方法（即提供默认实现，但可以被具体类覆盖）或者抽象方法（即没有具体实现，需要由具体类来实现）。这样，在抽象类的模板方法中通过调用钩子方法，可以提供一个扩展点，具体类可以选择性地覆盖钩子方法，以实现个性化的定制。如果具体类不覆盖钩子方法，将使用抽象类中定义的默认实现。

        4、模板方法（Template Method）：模板方法是抽象类中定义的核心方法，它规定了算法的骨架和执行顺序，而具体的步骤则由具体类来实现。模板方法通过调用抽象类中定义的具体方法、抽象方法和钩子方法，完成算法的整体流程。

        在模板方法模式中，抽象类起到了定义算法骨架和提供公共方法的作用，具体类则负责实现算法的具体细节。通过将变化部分封装在具体类中，模板方法模式实现了算法的复用与扩展。这样，当需要修改或添加新的算法时，只需创建新的具体类，并在其中实现具体步骤即可，而不需要修改抽象类和其他具体类的代码。这样的设计能够提高代码的灵活性、可维护性和可扩展性。

    2.3 类图

    在这里插入图片描述
    类图和上面的角色进行对应：
    1：AbstractClass 抽象类
    2：Concrete Class 具体类
    3：primitiveOperation 1和primitiveOperation 2 钩子方法
    4：templateMethod 模板方法

    2.4 工作流程

    模版方法遵循以下工作流程：

    1、定义抽象类，声明模版方法和抽象方法。
    2、实现抽象类，提供模版方法的具体实现，其中某些步骤使用抽象方法。
    3、派生具体类，继承抽象类并实现抽象方法。

    3. 应用场景

    3.1 适用情况：

        在一个算法的框架下，允许子类根据需要扩展或修改某些步骤。
        多个相关的类拥有相似的行为，可以使用模版方法将公共操作提取到抽象类中。

    3.2 常见例子：

        1、数据库访问框架：在数据库访问框架中，可以使用模板方法模式定义一个通用的数据访问流程。抽象类中的模板方法定义了打开数据库连接、执行SQL语句、处理结果集等具体步骤。具体类可以继承该抽象类并实现具体数据库的访问细节，如MySQL、Oracle等，从而实现针对不同数据库的操作。

        2、游戏开发中的角色AI：在游戏开发中，角色AI往往需要遵循一定的行为模式。可以使用模板方法模式定义一个抽象类，其中的模板方法描述了角色的基本行为流程，比如巡逻、攻击、逃跑等。具体角色类可以继承该抽象类并实现具体的行为细节，以适应不同类型的角色AI。

        3、咖啡和茶的冲泡过程：冲泡咖啡和茶的过程有许多共同的步骤，比如烧水、加入咖啡或茶叶、搅拌等。可以使用模板方法模式定义一个饮料冲泡的抽象类，其中的模板方法描述了整个冲泡的流程。具体子类可以分别实现咖啡和茶的具体冲泡细节，从而创建不同类型的饮料。

        4、操作系统中的进程调度算法：在操作系统的进程调度中，有各种调度算法，比如先来先服务（FCFS）、时间片轮转等。可以使用模板方法模式定义一个抽象类，其中的模板方法描述了进程调度的基本流程，包括进程就绪队列的管理、时间片分配等。具体子类可以继承该抽象类并实现具体的调度算法细节，以适应不同的调度策略。

    4. 代码衍化过程

    业务背景：每个人都要抄一样的考卷，然后再将自己的答案写上

    初版：甲乙学生都抄试卷

    //甲抄的试卷
public class TestPaperA {
    public void testQuestion1() {
        System.out.println("试题1题目内容");
        System.out.println("答案：b");
    } public void testQuestion2() {
        System.out.println("试题2题目内容");
        System.out.println("答案：c");
    } public void testQuestion3() {
        System.out.println("试题3题目内容");
        System.out.println("答案：b");
    }
}

//乙抄的试卷
public class TestPaperB {
    public void testQuestion1() {
        System.out.println("试题1题目内容");
        System.out.println("答案：a");
    } public void testQuestion2() {
        System.out.println("试题2题目内容");
        System.out.println("答案：b");
    } public void testQuestion3() {
        System.out.println("试题3题目内容");
        System.out.println("答案：b");
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        System.out.println("写生甲抄的试卷：");
        TestPaperA studentA=new TestPaperA();
        studentA.testQuestion1();
        studentA.testQuestion2();
        studentA.testQuestion3();
        System.out.println("----------------------------------------");
        System.out.println("写生乙抄的试卷：");
        TestPaperA studentB=new TestPaperA();
        studentB.testQuestion1();
        studentB.testQuestion2();
        studentB.testQuestion3();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

        从上面的代码中可以看出学生甲和学生乙分别抄了试卷（两个类），试卷类非常类似，除了答案不同。
        这样的代码，容易错，还非常难以维护

    第二版：提炼代码

    //试卷父类
public class TestPaper {
    public void testQuestion1() {
        System.out.println("试题1题目内容");

    } public void testQuestion2() {
        System.out.println("试题2题目内容");

    } public void testQuestion3() {
        System.out.println("试题3题目内容");

    }
}

//甲的答卷
public class TestPaperA extends TestPaper {
    public void testQuestion1() {
       super.testQuestion1();
        System.out.println("答案：b");
    } public void testQuestion2() {
        super.testQuestion1();
        System.out.println("答案：c");
    } public void testQuestion3() {
        super.testQuestion3();
        System.out.println("答案：b");
    }
}

//乙的答卷
public class TestPaperB extends TestPaper {
    public void testQuestion1() {
       super.testQuestion1();
        System.out.println("答案：b");
    } public void testQuestion2() {
        super.testQuestion1();
        System.out.println("答案：a");
    } public void testQuestion3() {
        super.testQuestion3();
        System.out.println("答案：b");
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        System.out.println("写生甲的试卷：");
        designpatterns.template.testPaper.TestPaperA studentA=new designpatterns.template.testPaper.TestPaperA();
        studentA.testQuestion1();
        studentA.testQuestion2();
        studentA.testQuestion3();
        System.out.println("----------------------------------------");
        System.out.println("写生乙的试卷：");
        designpatterns.template.testPaper.TestPaperA studentB=new TestPaperA();
        studentB.testQuestion1();
        studentB.testQuestion2();
        studentB.testQuestion3();
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60

        上面的代码中将试题抽取出来作为父类，甲乙同学只需要写上答案即可。
        但是甲和乙的还是有很多重复的操作，既然用了继承，就应该把所有重复代码上升到父类

    第三版：抽象出算法骨架

    //试卷父类
abstract class TestPaper {
    public void testQuestion1() {
        System.out.println("试题1题目内容");
        System.out.println("答案是："+this.answer1());

    }
    protected abstract String answer1();


    public void testQuestion2() {
        System.out.println("试题2题目内容");
        System.out.println("答案是："+this.answer2());
    }
    protected abstract String answer2();

    public void testQuestion3() {
        System.out.println("试题3题目内容");
        System.out.println("答案是："+this.answer3());
    }
    protected abstract String answer3();
}

//甲的答卷
public class TestPaperA extends TestPaper{

    @Override
    protected String answer1() {
        return "b";
    }

    @Override
    protected String answer2() {
        return "a";
    }

    @Override
    protected String answer3() {
        return "b";
    }
}

//乙的答卷
public class TestPaperB extends TestPaper{

    @Override
    protected String answer1() {
        return "a";
    }

    @Override
    protected String answer2() {
        return "a";
    }

    @Override
    protected String answer3() {
        return "b";
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        System.out.println("学生甲的试卷：");
        TestPaper studentA=new TestPaperA();
        studentA.testQuestion1();
        studentA.testQuestion2();
        studentA.testQuestion3();
        System.out.println("_______________");
        System.out.println("学生甲的试卷：");
        TestPaper studentB=new TestPaperA();
        studentB.testQuestion1();
        studentB.testQuestion2();
        studentB.testQuestion3();
    }
}
 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78

        这一版代码将共同的部分放在父类中的模板方法中，父类中定义一个算法的骨架，具体实现交给子类的方法来完成。
        但是这一版中的客户端中仍然存在很多重复的代码

    第四版：模板方法

    //模板
abstract class AbstractClass {
    public void templateMethod(){
        //写一些可以被子类共享的代码

        //调用
        this.primitiveOperation1();
        this.primitiveOperation2();
    }
    public abstract  void primitiveOperation1();//子类个性的行为，放到子类去实现
    public abstract  void primitiveOperation2();

}

//具体板式A
public class ConcreteClassA extends AbstractClass{

    @Override
    public void primitiveOperation1() {
        System.out.println("具体类A方法1实现");
    }

    @Override
    public void primitiveOperation2() {
        System.out.println("具体类A方法2实现");
    }
}

//具体板式B
public class ConcreteClassB extends AbstractClass{

    @Override
    public void primitiveOperation1() {
        System.out.println("具体类B方法1实现");
    }

    @Override
    public void primitiveOperation2() {
        System.out.println("具体类B方法2实现");
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        AbstractClass concreteClass;
        concreteClass = new ConcreteClassA();
        concreteClass.templateMethod();


        concreteClass = new ConcreteClassB();
        concreteClass.templateMethod();

    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    输出结果
    在这里插入图片描述
    NS图
    在这里插入图片描述
    在这里插入图片描述

    变化过程总结及未来展望

    1、抽象题：把题目要求抽出来 TestPaper类（这里属于抽出相同部分）
    2、抽答案：把每个人的答案抽取出来，上面例子中的answer方法 （这里属于抽出不同部分）
    3、抽步骤：也就是算法骨架抽出来，还有钩子方法（抽相同和不同）
    4、方法个数一样就可以抽象：这种想法的来源于上面例子的第四版，primitiveOperation方法里面只有一句打印，说明内容你可以随便定义，方法起一样的名字，实现完全不一样。进而抽象为只要方法的个数一样时也可以考虑用到模板方法。
    5、方法个数不一样，3个4个，就把3个抽出来：这一点就是更抽象了，即便方法个数不一样，也可以抽取其中一样个数的方法使用模板方法来实现。

        4和5是非常抽象了，所以需要想象力和创造力，把不一样的看成一样的。这也就是不是山也是山的过程。

    5. 总结

        模版方法是一种非常有用的设计模式，它通过将算法的具体步骤交给子类实现，提供了代码复用和灵活性。通过抽象类和具体类的组织方式，模版方法使得代码更易于扩展和维护。在软件开发中，我们可以根据具体情况选择使用模版方法来解决问题。

  • 相关阅读:
    tiup cluster deploy
    Skywalking入门
    【Unity3D赛车游戏制作】设置面板搭建——UGUI复合控件Toggle
    一篇文章带你掌握MyBatis简化框架——MyBatisPlus
    规范系列之代码提交日志
    每日亿题之20220904
    7天学完Spring：基础学习结束，关于Spring事务及其传播机制
    Python某网站壁纸图片数据, 实现网站JS逆向解密
    面向OLAP的列式存储DBMS-13-[ClickHouse]的MergeTree表引擎原理解析
    SpringBoot实现i18n国际化配置（超详细之跟着走就会系列）
  • 原文地址：https://blog.csdn.net/lisainan66/article/details/132856316