登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›【模板方法设计模式详解】C/Java/JS/Go/Python/TS不同语 ...

【模板方法设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

阜逐忍 2025-6-6 09:47:41
简介

模板方法模式（Template Method Pattern）也叫模板模式，是一种行为型模式。它定义了一个抽象公开类，包含基本的算法骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变算法的结构，只是重定义该算法的某些特定步骤。不同的子类以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。以此基于公共的模板，来实现实现不同的功能。
模板模式适用于一些复杂操作进行步骤分割、抽取公共部分由抽象父类实现、将不同的部分在父类中定义抽象实现、而将具体实现过程由子类完成。对于有多个子类具有共有的方法，且逻辑相同，可以考虑作为模板方法。
作用


  • 相同的部分父类给出统一的模板，子类大量复用，从而节省代码，复用逻辑。
  • 封装不变部分，扩展可变部分，行为由父类控制，子类灵活实现，便于维护和扩展。
实现步骤


  • 创建一个抽象的模板类，定义基本流程，同时定义一些基本方法供子类去实现。
  • 创建多个子类继承抽象模板，覆盖父类的相关动作和方法。
UML

 
template-pattern.pngJava代码

抽象模板类
  1. // GameTemplate.java 定义抽象模板类，有抽象方法和具体方法
  2. public abstract class GameTemplate {
  4.    // 抽象方法待子类来实现
  5.    abstract void init();
  7.    abstract void start();
  9.    abstract void end();
  11.    // 可复用的算法流程
  12.    public void play() {
  14.       System.out.println(this.getClass().getSimpleName() + "::play()");
  16.       // 初始化游戏
  17.       init();
  19.       // 开始游戏
  20.       start();
  22.       // 结束游戏
  23.       end();
  24.    }
  26. }
复制代码
具体业务类，继承抽象模板
  1. // Basketball.java  定义子类覆写父类抽象方法
  2. public class Basketball extends GameTemplate {
  4.    @Override
  5.    void init() {
  6.       System.out.println("Basketball::init() [Basketball Game Initialized! Start playing.]");
  7.    }
  9.    @Override
  10.    void start() {
  11.       System.out.println("Basketball::start() [Basketball Game Started. Enjoy the game!]");
  12.    }
  14.    @Override
  15.    void end() {
  16.       System.out.println("Basketball::end() [Basketball Game Finished!]");
  17.    }
  19. }
复制代码
  1. // Football.java 定义子类覆写父类抽象方法
  2. public class Football extends GameTemplate {
  4.    @Override
  5.    void init() {
  6.       System.out.println("Football::init() [Football Game Initialized! Start playing.]");
  7.    }
  9.    @Override
  10.    void start() {
  11.       System.out.println("Football::start() [Football Game Started. Enjoy the game!]");
  12.    }
  14.    @Override
  15.    void end() {
  16.       System.out.println("Football::end() [Football Game Finished!]");
  17.    }
  19. }
复制代码
  1. // Tennis.java 定义子类覆写父类抽象方法
  2. public class Tennis extends GameTemplate {
  4.    @Override
  5.    void init() {
  6.       System.out.println("Tennis::init() [Tennis Game Initialized! Start playing.]");
  7.    }
  9.    @Override
  10.    void start() {
  11.       System.out.println("Tennis::start() [Tennis Game Started. Enjoy the game!]");
  12.    }
  14.    @Override
  15.    void end() {
  16.       System.out.println("Tennis::end() [Tennis Game Finished!]");
  17.    }
  19.    // 在调用父类play之前，如果要执行自己的行为，也可以覆盖父类方法
  20.    // 先执行自己的，再调用父类的方法
  21.    @Override
  22.    public void play() {
  23.       System.out.println("Tennis::play() [Tennis Game play!]");
  24.       super.play();
  25.    }
  26. }
复制代码
测试调用
  1.     /**
  2.      * 模板方法模式就是当子类具备类似行为的时候，让子类共用一套流程
  3.      * 创建一个公共模板，确定公用流程和操作动作，子类覆盖具体的动作
  4.      */
  5.     GameTemplate football = new Football();
  6.     football.play();
  8.     System.out.println("===");
  9.     GameTemplate basketball = new Basketball();
  10.     basketball.play();
  12.     System.out.println("===");
  13.     GameTemplate tennis = new Tennis();
  14.     tennis.play();
复制代码
C语言代码

头文件

// func.h
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <stdlib.h>
  4. #include <stdbool.h>
  5. #include <string.h>
  7. typedef struct GameTemplate GameTemplate;
  8. typedef struct Football Football;
  9. typedef struct Basketball Basketball;
  10. typedef struct Tennis Tennis;
  12. // 定义抽象模板，包括各种动作和公共流程
  13. typedef struct GameTemplate
  14. {
  15.   char name[50];
  16.   void (*init)(GameTemplate *game);
  17.   void (*start)(GameTemplate *game);
  18.   void (*end)(GameTemplate *game);
  19.   void (*play)(GameTemplate *game);
  20. } GameTemplate;
  21. void template_play(GameTemplate *game);
  22. GameTemplate *game_template_constructor(char *name);
  24. // 定义子类覆写父类抽象方法
  25. typedef struct Football
  26. {
  27.   char name[50];
  28.   void (*init)(Football *game);
  29.   void (*start)(Football *game);
  30.   void (*end)(Football *game);
  31.   void (*play)(Football *game);
  32. } Football;
  33. Football *football_constructor(char *name);
  35. // 定义子类覆写父类抽象方法
  36. typedef struct Basketball
  37. {
  38.   char name[50];
  39.   void (*init)(Basketball *game);
  40.   void (*start)(Basketball *game);
  41.   void (*end)(Basketball *game);
  42.   void (*play)(Basketball *game);
  43. } Basketball;
  44. Basketball *basketball_constructor(char *name);
  46. // 定义子类覆写父类抽象方法
  47. typedef struct Tennis
  48. {
  49.   char name[50];
  50.   void (*init)(Tennis *game);
  51.   void (*start)(Tennis *game);
  52.   void (*end)(Tennis *game);
  53.   void (*play)(Tennis *game);
  54. } Tennis;
  55. Tennis *tennis_constructor(char *name);
复制代码
抽象模板类
  1. // game_template.c 定义抽象模板类，有抽象方法和具体方法
  2. #include "func.h"
  4. // 定义抽象模板类的公共部分，这里用struct替代
  6. // 抽象方法待子类来实现
  7. void template_init(GameTemplate *game) {}
  8. void template_start(GameTemplate *game)
  9. {
  10.   printf("\r\n GameTemplate::start() [GameTemplate Initialized! Start playing.]");
  11. }
  12. void template_end(GameTemplate *game) {}
  14. // 可复用的算法流程
  15. void template_play(GameTemplate *game)
  16. {
  17.   printf("\r\n GameTemplate::play() [name=%s]", game->name);
  19.   // 初始化游戏
  20.   game->init(game);
  22.   // 开始游戏
  23.   game->start(game);
  25.   // 结束游戏
  26.   game->end(game);
  27. }
  29. GameTemplate *game_template_constructor(char *name)
  30. {
  31.   // printf("\r\n game_template_constructor() [构建GameTemplate]");
  32.   GameTemplate *game = (GameTemplate *)malloc(sizeof(GameTemplate));
  33.   strcpy(game->name, name);
  34.   game->init = &template_init;
  35.   game->start = &template_start;
  36.   game->end = &template_end;
  37.   game->play = &template_play;
  38.   return game;
  39. }
复制代码
具体业务类，继承抽象模板
  1. // basketball.c  定义子类覆写父类抽象方法
  2. #include "func.h"
  4. // 定义子类覆写父类抽象方法
  5. void basketball_init(Basketball *game)
  6. {
  7.   printf("\r\n Basketball::init() [Basketball Game Initialized! Start playing.]");
  8. }
  10. void basketball_start(Basketball *game)
  11. {
  12.   printf("\r\n Basketball::start() [Basketball Game Started. Enjoy the game!]");
  13. }
  15. void basketball_end(Basketball *game)
  16. {
  17.   printf("\r\n Basketball::end() [Basketball Game Finished!]");
  18. }
  20. Basketball *basketball_constructor(char *name)
  21. {
  22.   printf("\r\n basketball_constructor() [构建Basketball]");
  23.   GameTemplate *template = game_template_constructor(name);
  24.   Basketball *game = (Basketball *)template;
  25.   game->init = &basketball_init;
  26.   // 如果不覆盖则使用基类的函数
  27.   // game->start = &basketball_start;
  28.   game->end = &basketball_end;
  29.   return game;
  30. }
复制代码
  1. // football.c 定义子类覆写父类抽象方法
  2. #include "func.h"
  4. // 定义子类覆写父类抽象方法
  5. void football_init(Football *game)
  6. {
  7.   printf("\r\n Football::init() [Football Game Initialized! Start playing.]");
  8. }
  10. void football_start(Football *game)
  11. {
  12.   printf("\r\n Football::start() [Football Game Started. Enjoy the game!]");
  13. }
  15. void football_end(Football *game)
  16. {
  17.   printf("\r\n Football::end() [Football Game Finished!]");
  18. }
  20. Football *football_constructor(char *name)
  21. {
  22.   printf("\r\n football_constructor() [构建Football]");
  23.   GameTemplate *template = game_template_constructor(name);
  24.   Football *game = (Football *)template;
  25.   game->init = &football_init;
  26.   game->start = &football_start;
  27.   game->end = &football_end;
  28.   return game;
  29. }
复制代码
  1. // tennis.c 定义子类覆写父类抽象方法
  2. #include "func.h"
  4. // 定义子类覆写父类抽象方法
  5. void tennis_init(Tennis *game)
  6. {
  7.   printf("\r\n Tennis::init() [Tennis Game Initialized! Start playing.]");
  8. }
  10. void tennis_start(Tennis *game)
  11. {
  12.   printf("\r\n Tennis::start() [Tennis Game Started. Enjoy the game!]");
  13. }
  15. void tennis_end(Tennis *game)
  16. {
  17.   printf("\r\n Tennis::end() [Tennis Game Finished!]");
  18. }
  20. // 在调用父类play之前，如果要执行自己的行为，也可以覆盖父类方法
  21. void tennis_play(Tennis *game)
  22. {
  23.   // 先执行自己的内容，再调用基类的函数
  24.   printf("\r\n Tennis::play() [Tennis Game Play!]");
  25.   template_play((GameTemplate *)game);
  26. }
  28. Tennis *tennis_constructor(char *name)
  29. {
  30.   printf("\r\n tennis_constructor() [构建Tennis]");
  31.   GameTemplate *template = game_template_constructor(name);
  32.   Tennis *game = (Tennis *)template;
  33.   game->init = &tennis_init;
  34.   game->start = &tennis_start;
  35.   game->end = &tennis_end;
  36.   game->play = &tennis_play;
  37.   return game;
  38. }
复制代码
测试调用
  1. #include "../src/func.h"
  3. int main(void)
  4. {
  5.   printf("test start:\r\n");
  6.   /**
  7.    * 模板方法模式就是当子类具备类似行为的时候，让子类共用一套流程
  8.    * 创建一个公共模板，确定公用流程和操作动作，子类覆盖具体的动作
  9.    */
  10.   Football *football = football_constructor("football");
  11.   football->play(football);
  13.   printf("\r\n ===");
  14.   Basketball *basketball = basketball_constructor("basketball");
  15.   basketball->play(basketball);
  17.   printf("\r\n ===");
  18.   Tennis *tennis = tennis_constructor("basketball");
  19.   tennis->play(tennis);
  20. }
复制代码
更多语言版本

不同语言设计模式源码：https://github.com/microwind/design-pattern

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
阜逐忍
2025-6-6 09:47:41

0

粉丝关注

14

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫