策略模式与命令模式的区别 是什么？

最新推荐文章于 2024-08-26 20:03:02 发布
转载 最新推荐文章于 2024-08-26 20:03:02 发布 · 236 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/baiduligang/p/4247312.html
文章标签：

#设计模式

本文深入探讨了策略模式与命令模式的区别，解释了设计模式如何通过封装算法来提高软件的灵活性和可维护性。重点阐述了策略模式解决单一问题，而命令模式处理多个问题的能力。同时，文章提供了设计模式之间的相似性和差异性分析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


策略模式 把易于变化的行为分别封装起来，让它们之间可以互相替换， 让这些行为的变化独立于拥有这些行为的客户。

  GoF《设计模式》中说道：定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。该模式使得算法可独立于它们的客户变化。

Command命令模式是一种对象行为型模式，它主要解决的问题是：在软件构建过程中，“行为请求者”与“行为实现者”通常呈现一种“紧耦合”的问题。
  GoF《设计模式》中说道：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。 

 

我个人觉得，策略模式和命令模式的其中一个最大区别，是在于：策略模式对付的问题域通常是一个，就是说，多个策略只是处理同一个问题，而命令模式对付的是多个问题域，就是很多不同的命令来做不同的事情。

各种设计模式之间，有很多相似之处，只是由于侧重的方向不同。

转载于:https://www.cnblogs.com/baiduligang/p/4247312.html

【Java 行为型设计模式 II】策略模式、命令模式详解
おうせき碩の博客
06-16 495
  愿你如阳光，明媚不忧伤。 目録4. 策略模式策略模式优点和缺点策略模式的应用场景策略模式的结构策略模式的实现策略模式的扩展   4. 策略模式 Strategy 定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。例如去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但是办理具体业务却因人而
设计模式-07_模板方法模式&策略模式&命令模式&责任链模式
m0_62036548的博客
08-13 1126
设计模式-07_模板方法模式&策略模式&命令模式&责任链模式
对比Java设计模式编程中的状态模式和策略模式
09-02
主要介绍了Java设计模式编程中的状态模式和策略模式对比,文中列举了两种模式的相似点和不同点,并都举了代码的实例作为参照,需要的朋友可以参考下
命令模式与策略模式的区别
XXX的专栏
03-22 1603
-- 相同点：    -- 毫无疑问，第一个相同点肯定是：封装变化。策略模式封装算法的变法，命令模式封装请求的变化。    -- 都使用组合来实现功能，达到解耦的目的。    -- 如果我们将命令模式做更高层次上的抽象，可以将它看成是一种策略模式。如：我们将Client与       Invoker封装到一起，将Concrete Command与Receiver封装到一起。 -- 策略(
策略模式和命令模式的区别
qq_19305529的博客
04-06 566
策略模式主要针对算法抽象（Strategy策略接口），它将每个算法封装到一个单独的类中，使得客户端可以根据具体情况在这些策略之间进行切换，策略模式关注的是定义一系列可互换的算法或行为，允许在运行时选择和替换不同的策略。而命令模式则是针对请求抽象（Command命令接口），Command通过将任何操作转换为对象，操作的参数将成为该对象的字段。从而实现使得请求可以被存储、延迟、排队、撤销、重试以及发送到远程服务器等。策略模式侧重于不同策略类实现与切换，而命令模式则侧重于对（不同）​​​​​​​请求的封装
策略模式与命令模式区别
Stroller
11-17 9375
策略模式 把易于变化的行为分别封装起来，让它们之间可以互相替换， 让这些行为的变化独立于拥有这些行为的客户。   GoF《设计模式》中说道：定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。该模式使得算法可独立于它们的客户变化。 Command命令模式是一种对象行为型模式，它主要解决的问题是：在软件构建过程中，“行为请求者”与“行为实现者”通常呈现一种“紧耦合”的问题。
状态模式，命令模式和策略模式的区别
hongchangfirst
09-14 4422
设计模式中有三个模式State, Command, Strategy，这三种设计模式都是行为型设计模式，在结构上又都很像，所以很多时候分不清楚。 区分这三种模式不要focus在结构上，这三种模式最主要是在使用意图上有区别： 状态模式：内部维护一个状态，会随着public api的调用进行相应的状态转移。外界不需要知道状态及其变化情况。 命令模式：根据客户的请求封装相应的命令，处理者就
浅谈简单工作流设计——责任链模式配合策略与命令模式的实现
03-04
本文以项目中的一个工作流模块，演示责任链模式、策略模式、命令模式的组合实现！最近在做的一个项目，涉及到的是一个流程性质的需求。关于工程机械行业的服务流程：服务任务流程和备件发运流程。项目之初，需求不是...
策略模式（Strategy Pattern）详解 1. 什么是策略模式？ 2. 为什么需要策略模式？ 3. 策略模式的核心概念 3.1 策略（Strategy） 3.2 具体策略（Concrete S
04-24
1. 什么是策略模式？ 2. 为什么需要策略模式？ 3. 策略模式的核心概念 3.1 策略（Strategy） 3.2 具体策略（Concrete Strategy） 3.3 上下文（Context） 4. 策略模式的结构 5. 策略模式的基本实现 5.1 基础示例：...
命令模式VS策略模式
water
09-25 370
行为模式：关注系统中对象之间的相互交互，研究系统在运行时对象之间的相互通信和协作，进一步明确对象的职责，共11种模式。模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。本文主要对方命令模式和策略模式的 1 策略模式和命令模式的不同之处： （1）策略模式的主要意图是封装算法，对于他来说，“算法...
命令模式与策略模式的比较：选择合适的设计模式
2401_85639015的博客
08-26 1366
设计模式是软件设计中的最佳实践总结，是经过反复验证的解决方案，用于解决面向对象设计中常见的问题。设计模式不仅可以提高开发效率，还能增强代码的可读性和复用性。命令模式（Command Pattern）是一种行为型设计模式，它将请求封装为对象，从而允许用户用不同的请求、队列或者日志来参数化对象。命令模式还支持可撤销的操作。策略模式（Strategy Pattern）也是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式使得算法的变化不会影响使用算法的客户端。
【设计模式】 模式PK：命令模式VS策略模式
09-04 171
1、概述 　　命令模式和策略模式的类图确实很相似，只是命令模式多了一个接收者（Receiver）角色。它们虽然同为行为类模式，但是两者的区别还是很明显的。策略模式的意图是封装算法，它认为“算法”已经是一个完整的、不可拆分的原子业务（注意这里是原子业务，而不是原子对象），即其意图是让这些算法独立，并且可以相互替换，让行为的变化独立于拥有行为的客户；而命令模式则是对动作的解耦，把一个动作的...
命令模式，及与策略模式的区别
qq_46041588的博客
11-02 775
策略模式的意图是封装算法，它认为“算法”已经是一个完整的、不可拆分的原子业务，即其意图是让这些算法独立，并且可以相互替换，让行为的变化独立于拥有行为的客户。命令模式则是对动作的解耦，把一个动作的执行分为执行对象（接收者角色）、执行行为（命令角色），让两者相互独立而不相互影响。命令模式：对命令的封装，每一个命令都是一个操作，请求方发出请求，接收方接收请求，并执行操作。请求者角色Control构造器注入具体的命令角色(openCommand)了请求方和接收方，命令模式属于行为型模式。command：命令接口。
策略模式和命令模式的不同
Nozomi_Ame的博客
09-19 615
策略模式和命令模式
策略模式和命令模式的PK
秋殇
01-12 606
策略模式它的意图是封装算法，它认为算法是一个整体，是相互独立的，并且是可以相互替换的，让算法的行为独立于客户。命令模式它的意图是解耦，它让执行命令者和发布命令者分离。实现一个压缩和解压缩的功能，这个功能有两种算法：一种是gzip，一种是zip。1. 策略模式的实现：代码：interface IReceiver{ public void zipExecute(); public voi
命令模式和策略模式
H2509130723的博客
08-12 1299
命令模式和策略模式 @author huangdailin on 2019/8/6 命令模式 定义： 命令模式定义：将一个请求封装为一个对象，使发出请求的责任和执行请求责任分割开。这样两者之间通过命令对象进行沟通，方便将命令对象进行存储、传递、增加和管理。 结构与实现： 可以将系统中的相关操作抽象为命令，使调用者与实现者相关分离。 模式的结构 命令模式包含以下主要角色。 抽象命令类角色：...
设计模式：“命令模式”、“策略模式”、“状态模式”的区别
netyeaxi的专栏
03-26 1472
“命令模式”、“策略模式”、“状态模式”的区别
23种设计模式之命令模式和策略模式的区别
致力于不留技术债务cuizb.top
08-22 2631
命令模式和策略模式确实很相似，只是命令模式多了一个接收者（Receiver）角色。它们虽然同为行为类模式，但是两者的区别还是很明显的。策略模式的意图是封装算法，它认为“算法”已经是一个完整的、不可拆分的原子业务（注意这里是原子业务，而不是原子对象），即其意图是让这些算法独立，并且可以相互替换，让行为的变化独立于拥有行为的客户；而命令模式则是对动作的解耦，把一个动作的执行分为执行对象（接收者角色）、执行行为（命令角色），让两者相互独立而不相互影响。
状态模式与策略模式，命令模式的区别
樱桃小丸子
06-03 376
状态模式 稳定点 对象具有不同的状态，状态和多个行为相关联。即一个对象有多个行为收到状态的控制。即在多个方法中要获取状态，让方法联动 与策略模式区别 一个具体的实现方法，有多种不同的实现方式，不同的实现方式就是策略 与命令模式区别 多个对象具有相同的行为（发送者），点击执行某些方法，方法的实现方式可能不同或者为了屏蔽系统差异，需要封装到不同的对象里（接收者），中间加一层命令对象连接 ...
命令模式与策略模式的主要区别是什么？
最新发布
07-15
<think>命令模式与策略模式的主要区别： 1. **目的不同**： - 策略模式：定义一系列算法，使它们可以互相替换，让算法独立于客户端而变化。 - 命令模式：将请求封装成对象，以便使用不同的请求、队列或日志来参数化其他对象，并支持可撤销操作。 2. **关注点不同**： - 策略模式关注的是算法的互换性和封装，客户端通常主动选择不同的策略。 - 命令模式关注的是操作的封装和请求的发送者与接收者的解耦，通常用于支持撤销、队列、日志等。 3. **使用方式不同**： - 在策略模式中，客户端通常知道可用的策略并主动切换。 - 在命令模式中，客户端创建命令对象，然后由调用者执行，客户端可能不知道具体命令的实现。 4. **类结构差异**： - 策略模式：一个Context类持有一个策略接口的引用，策略接口有多个具体实现（算法）。 - 命令模式：一个Invoker类持有命令接口的引用，命令接口有多个具体实现（操作），每个具体命令持有接收者（执行实际操作的对象）的引用。 5. **功能扩展**： - 命令模式支持撤销（undo）和重做（redo）功能，而策略模式通常不支持。 下面用代码示例说明两种模式： ### 策略模式示例 ```java // 策略接口 interface SortingStrategy { void sort(int[] data); } // 具体策略：冒泡排序 class BubbleSort implements SortingStrategy { public void sort(int[] data) { System.out.println("Using bubble sort"); // 实现冒泡排序算法 // ... } } // 具体策略：快速排序 class QuickSort implements SortingStrategy { public void sort(int[] data) { System.out.println("Using quick sort"); // 实现快速排序算法 // ... } } // 上下文类 class Sorter { private SortingStrategy strategy; public void setStrategy(SortingStrategy strategy) { this.strategy = strategy; } public void executeSort(int[] data) { strategy.sort(data); } } // 客户端使用 public class StrategyDemo { public static void main(String[] args) { Sorter sorter = new Sorter(); int[] data = {5, 2, 7, 1}; // 使用冒泡排序 sorter.setStrategy(new BubbleSort()); sorter.executeSort(data); // 切换到快速排序 sorter.setStrategy(new QuickSort()); sorter.executeSort(data); } } ``` ### 命令模式示例（带撤销功能） ```java // 命令接口 interface Command { void execute(); void undo(); } // 接收者：执行实际操作的对象 class TextEditor { private StringBuilder text = new StringBuilder(); private String lastDeleted; public void write(String newText) { text.append(newText); } public void deleteLastWord() { if (text.length() > 0) { lastDeleted = text.substring(text.lastIndexOf(" ") + 1); text.delete(text.lastIndexOf(" "), text.length()); } } public String getText() { return text.toString(); } public String getLastDeleted() { return lastDeleted; } } // 具体命令：写入命令 class WriteCommand implements Command { private TextEditor editor; private String text; public WriteCommand(TextEditor editor, String text) { this.editor = editor; this.text = text; } public void execute() { editor.write(text); } public void undo() { // 撤销写入：删除最后添加的文本 // 这里简化处理，实际可能需要记录位置 // 注意：这个撤销操作并不完美，仅用于示例 editor.deleteLastWord(); } } // 调用者 class Invoker { private Command command; private Stack<Command> history = new Stack<>(); public void setCommand(Command command) { this.command = command; } public void executeCommand() { command.execute(); history.push(command); } public void undo() { if (!history.isEmpty()) { Command lastCommand = history.pop(); lastCommand.undo(); } } } // 客户端使用 public class CommandDemo { public static void main(String[] args) { TextEditor editor = new TextEditor(); Invoker invoker = new Invoker(); // 创建并执行写入命令 Command writeHello = new WriteCommand(editor, "Hello "); invoker.setCommand(writeHello); invoker.executeCommand(); // 文本变为 "Hello " Command writeWorld = new WriteCommand(editor, "World!"); invoker.setCommand(writeWorld); invoker.executeCommand(); // 文本变为 "Hello World!" // 撤销 invoker.undo(); // 撤销"World!" -> 文本变为 "Hello " System.out.println(editor.getText()); } } ``` ### 关键区别总结表 | 特性 | 策略模式 | 命令模式 | |--------------|------------------------------|------------------------------| | **主要目的** | 封装和互换算法 | 封装操作请求和解耦 | | **核心角色** | 策略接口、具体策略、上下文 | 命令接口、具体命令、调用者、接收者 | | **撤销支持** | 不支持 | 支持 | | **队列/日志**| 不支持 | 支持 | | **使用场景** | 需要动态切换算法 | 需要撤销、事务、宏命令等功能 | §§相关问题§§: 1. 策略模式在哪些实际应用场景中最常用？ 2. 命令模式如何实现宏命令（组合多个命令）？ 3. 策略模式和状态模式有何异同？ 4. 在命令模式中，如何处理命令执行过程中的异常？</think># 命令模式与策略模式的主要区别 命令模式和策略模式都是行为设计模式，它们都通过封装变化来提高代码的灵活性，但它们的应用场景和设计目的有本质区别。 ## 核心区别总结 | 特性 | 命令模式 | 策略模式 | |--------------|----------------------------------|--------------------------------| | **主要目的** | 封装请求为对象 | 封装算法系列 | | **关注点** | 请求的封装和执行机制 | 算法的选择和互换 | | **撤销/重做**| 支持（核心特性） | 不支持 | | **队列支持** | 支持（可排队执行） | 不支持 | | **对象关系** | 命令对象知道接收者 | 策略对象不知道上下文 | | **典型应用** | 操作历史、事务处理、任务队列 | 算法选择、支付方式、排序策略 | ## 代码示例对比 ### 策略模式实现（支付场景） ```java // 策略接口 interface PaymentStrategy { void pay(double amount); } // 具体策略实现 class CreditCardPayment implements PaymentStrategy { public void pay(double amount) { System.out.println("Paid $" + amount + " via Credit Card"); } } class PayPalPayment implements PaymentStrategy { public void pay(double amount) { System.out.println("Paid $" + amount + " via PayPal"); } } // 上下文类 class PaymentContext { private PaymentStrategy strategy; public void setPaymentStrategy(PaymentStrategy strategy) { this.strategy = strategy; } public void executePayment(double amount) { strategy.pay(amount); } } // 客户端使用 public class StrategyDemo { public static void main(String[] args) { PaymentContext context = new PaymentContext(); context.setPaymentStrategy(new CreditCardPayment()); context.executePayment(100.0); context.setPaymentStrategy(new PayPalPayment()); context.executePayment(50.0); } } ``` ### 命令模式实现（文本编辑器场景） ```java // 命令接口 interface Command { void execute(); void undo(); } // 接收者类 class TextEditor { private StringBuilder text = new StringBuilder(); public void addText(String newText) { text.append(newText); } public void deleteText(int length) { if (length > text.length()) length = text.length(); text.delete(text.length() - length, text.length()); } public String getText() { return text.toString(); } } // 具体命令类 class AddTextCommand implements Command { private TextEditor editor; private String text; public AddTextCommand(TextEditor editor, String text) { this.editor = editor; this.text = text; } public void execute() { editor.addText(text); } public void undo() { editor.deleteText(text.length()); } } // 调用者类 class Invoker { private Stack<Command> history = new Stack<>(); public void executeCommand(Command command) { command.execute(); history.push(command); } public void undoLastCommand() { if (!history.isEmpty()) { Command lastCommand = history.pop(); lastCommand.undo(); } } } // 客户端使用 public class CommandDemo { public static void main(String[] args) { TextEditor editor = new TextEditor(); Invoker invoker = new Invoker(); invoker.executeCommand(new AddTextCommand(editor, "Hello ")); invoker.executeCommand(new AddTextCommand(editor, "World!")); System.out.println("Current text: " + editor.getText()); // "Hello World!" invoker.undoLastCommand(); System.out.println("After undo: " + editor.getText()); // "Hello " } } ``` ## 关键区别详解 1. **目的不同**： - 策略模式：封装一系列可互换的算法，让算法独立于使用它的客户端而变化 - 命令模式：将请求封装为对象，使你可以参数化客户端对象，队列请求，记录日志，支持撤销操作 2. **撤销/重做支持**： - 命令模式直接支持撤销操作（核心特性） - 策略模式不支持撤销操作，因为策略是算法而非操作 3. **对象关系**： - 策略模式中，策略对象通常不知道上下文对象 - 命令模式中，命令对象知道接收者对象（执行操作的目标） 4. **使用场景**： - 策略模式：当有多个相关类仅在行为上不同时，或需要算法的不同变体时 - 命令模式：当需要参数化对象、排队请求、支持撤销操作或记录请求日志时 5. **生命周期**： - 策略对象通常长期存在，作为配置的一部分 - 命令对象通常是短期的，执行后被丢弃或存储在历史记录中 ## 何时使用哪种模式 ### 使用策略模式当： - 需要多种算法变体 - 算法需要独立于使用它们的客户端 - 需要在运行时选择算法 - 有多个条件语句用于选择算法 ### 使用命令模式当： - 需要参数化对象 - 需要支持撤销/重做操作 - 需要将操作放入队列并在不同时间执行 - 需要记录操作历史 - 需要支持事务操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值