设计模式总结 通过命令模式

第1篇一、实验背景随着软件工程的不断发展，设计模式作为一种解决软件开发中常见问题的有效方法，越来越受到广泛关注。

本次实验旨在通过学习设计模式，提高编程能力，掌握解决实际问题的方法，并加深对设计模式的理解。

二、实验目的1. 理解设计模式的基本概念和分类；2. 掌握常见设计模式的原理和应用；3. 提高编程能力，学会运用设计模式解决实际问题；4. 培养团队协作精神，提高项目开发效率。

三、实验内容本次实验主要涉及以下设计模式：1. 创建型模式：单例模式、工厂模式、抽象工厂模式、建造者模式；2. 结构型模式：适配器模式、装饰者模式、桥接模式、组合模式、外观模式；3. 行为型模式：策略模式、模板方法模式、观察者模式、责任链模式、命令模式。

四、实验过程1. 阅读相关资料，了解设计模式的基本概念和分类；2. 分析每种设计模式的原理和应用场景；3. 编写代码实现常见设计模式，并进行分析比较；4. 将设计模式应用于实际项目中，解决实际问题；5. 总结实验经验，撰写实验报告。

五、实验结果与分析1. 创建型模式（1）单例模式：通过控制对象的实例化，确保一个类只有一个实例，并提供一个访问它的全局访问点。

实验中，我们实现了单例模式，成功避免了资源浪费和同步问题。

（2）工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

实验中，我们使用工厂模式创建不同类型的交通工具，提高了代码的可扩展性和可维护性。

（3）抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

实验中，我们使用抽象工厂模式创建不同类型的计算机，实现了代码的复用和扩展。

（4）建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

实验中，我们使用建造者模式构建不同配置的房屋，提高了代码的可读性和可维护性。

2. 结构型模式（1）适配器模式：将一个类的接口转换成客户期望的另一个接口，使原本接口不兼容的类可以一起工作。

命令模式将请求封装成对象使得可以用不同的请求对客户进行参数化命令模式（Command Pattern）是一种行为设计模式，它将一个请求封装成一个对象，使得可以用不同的请求对客户进行参数化。

这种模式中，请求的调用者和请求的接收者解耦，使得调用者不需要知道请求的接收者的具体信息。

在实际的软件开发中，命令模式是一个非常常用的设计模式。

它可以用于实现菜单项的点击事件、处理用户交互的命令、撤销和重做操作等功能。

下面我们通过一个简单的例子来说明命令模式的使用场景和优势。

假设我们正在开发一个家庭智能控制系统，用户可以通过手机APP 控制家里的电器设备。

现在我们要实现一个功能，当用户点击“开灯”按钮时，系统能够自动打开客厅的灯。

这个功能可以通过命令模式来实现。

首先，我们定义一个抽象命令类(Command)，其中包含一个抽象方法execute()用于执行命令。

接下来，我们定义具体的命令类(LightOnCommand)，继承自抽象命令类，实现execute()方法，在execute()方法中调用相应的接收者(Light)的方法，完成具体的操作（打开灯）。

同时，我们还需要定义一个接收者类(Light)，其中包含打开灯的方法。

接下来，我们可以定义一个请求者(Invoker)类，该类包含一个命令对象(Command)作为成员变量，并提供一个方法用于设置命令对象。

在请求者类的方法中，调用命令对象的execute()方法实现请求的执行。

最后，我们可以编写一个客户端类(Client)，通过该类来测试命令模式的使用。

在客户端类中，我们实例化命令对象和接收者对象，将命令对象设置进请求者对象，然后调用请求者对象的方法。

这样，当用户点击“开灯”按钮时，请求者对象会调用命令对象的execute()方法，从而执行相应的命令，打开客厅的灯。

通过使用命令模式，我们可以很方便地实现对请求的封装和参数化。

比如，如果用户点击“关灯”按钮，我们只需要定义一个新的具体命令类(LightOffCommand)，实现execute()方法即可。

一、实验目的1. 理解命令模式的基本概念和原理。

2. 掌握命令模式在Java中的实现方法。

3. 分析命令模式在软件设计中的应用场景。

4. 通过实验加深对命令模式的理解和应用。

二、实验环境1. 操作系统：Windows 102. 开发工具：Eclipse IDE3. 编程语言：Java三、实验内容1. 命令模式基本概念命令模式是一种行为型设计模式，它将请求封装为一个对象，从而允许用户对请求进行参数化、排队或记录请求，以及支持可撤销的操作。

命令模式主要包含以下角色：- 抽象命令（Command）：定义了执行操作的接口。

- 具体命令（ConcreteCommand）：实现了抽象命令接口，定义了接收者对象和执行操作的方法。

- 接收者（Receiver）：知道如何执行与执行请求相关的操作。

- 调用者（Invoker）：负责发送请求，调用命令对象的execute方法执行操作。

- 客户端（Client）：创建具体命令对象，并设置接收者和调用者。

2. 命令模式实现（1）创建抽象命令类```javapublic interface Command {void execute();}```（2）创建具体命令类```javapublic class LightOnCommand implements Command { private Light light;public LightOnCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.on();}}public class LightOffCommand implements Command { private Light light;public LightOffCommand(Light light) {this.light = light;}@Overridepublic void execute() {light.off();}```（3）创建接收者类```javapublic class Light {public void on() {System.out.println("Light is on."); }public void off() {System.out.println("Light is off."); }}```（4）创建调用者类```javapublic class Invoker {private Command command;public void setCommand(Command command) { mand = command;}public void pressButton() {command.execute();}```（5）创建客户端类```javapublic class Client {public static void main(String[] args) {Light light = new Light();Command lightOnCommand = new LightOnCommand(light); Command lightOffCommand = new LightOffCommand(light); Invoker invoker = new Invoker();invoker.setCommand(lightOnCommand);invoker.pressButton(); // 输出：Light is on.invoker.setCommand(lightOffCommand);invoker.pressButton(); // 输出：Light is off.}}```3. 命令模式应用场景命令模式在以下场景中具有较好的应用：- 需要支持撤销（Undo）和重做（Redo）操作。

23种设计模式记忆口诀1.单例模式：独一无二，最重要。

2.工厂模式：制造者，无需说。

3.抽象工厂：一族产品，同根源。

4.建造者模式：一步一步，建造家。

5.原型模式：克隆专家，快捷法。

6.适配器模式：转换者，聪明智。

7.桥接模式：结构优化，灵活性。

8.装饰模式：装饰者，美化家。

9.组合模式：树形结构，组合家。

10.外观模式：微缩封装，简洁家。

11.享元模式：享元工厂，节省家。

12.代理模式：替身幕后，保护家。

13.模板方法：算法继承，不变家。

14.策略模式：行为封装，灵活家。

15.命令模式：命令者，有权家。

16.职责链模式：可扩展，级别性。

17.状态模式：状态管理，干净家。

18.观察者模式：被观察，自主家。

19.中介者模式：中介者，沟通家。

20.迭代器模式：循环选择，简化家。

21.访问者模式：动态添加，扩展家。

22.备忘录模式：状态备份，还原家。

23.解释器模式：解释语言，特殊家。

以上23种设计模式，为了更好地记忆，我把它们组合成了一个口诀：最重要的单例模式，工厂与抽象同皇冠。

建造渐进如养家，克隆是原型美化家。

适配器桥接转化家，组合成树形结构家。

装饰装扮美化家，微缩封装外观家。

享元共用节省家，代理替身保护家。

策略模式灵活家，命令者有权家。

职责链扩展级别性，状态干净管理家。

被观察自主家，中介者沟通家。

循环迭代简化家，访问者动态扩展家。

备忘录变化还原家，解释语言特殊家。

这个口诀是通过把每个模式的主要特点和功能用简洁的语句表达出来，然后通过排列组合的方式形成的。

相信这个口诀会让你更容易地记忆这23种设计模式，并且可以在以后的工作中灵活地运用它们。

C#23种设计模式汇总创建型模式在⼯⼚⽅法模式中，⼯⼚⽅法⽤来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这⼀细节。

⼯⼚⽅法模式的核⼼是⼀个抽象⼯⼚类，各种具体⼯⼚类通过抽象⼯⼚类将⼯⼚⽅法继承下来。

如此使得客户可以只关⼼抽象产品和抽象⼯⼚，完全不⽤理会返回的是哪⼀种具体产品，也不⽤关系它是如何被具体⼯⼚创建的。

抽象⼯⼚模式的主要优点是隔离了具体类的⽣成，使得客户不需要知道什么被创建了。

犹豫这种隔离，更换⼀个具体⼯⼚就变得相对容易。

所有的具体⼯⼚都实现了抽象⼯⼚中定义的那些公共接⼝，因此只需改变具体⼯⼚的实例，就可以在某种程度上改变这个软件的系统的⾏为。

另外，应⽤抽象⼯⼚模式符合GRASP纯虚构的模式，可以实现⾼内聚低耦合的设计⽬的，因此抽象⼯⼚模式得到了⼴泛应⽤。

建造者模式将⼀个复杂对象的⽣成责任作了很好的分配。

它把构造过程放在指挥者的⽅法中，把装配过程放到具体建造者类中。

建造者模式的产品之间都有共通点，但有时候，产品之间的差异性很⼤，这就需要借助⼯⼚⽅法模式或抽象⼯⼚模式。

另外，如果产品的内部变化复杂，Builder的每⼀个⼦类都需要对应到不同的产品去做构建的动作、⽅法，这就需要定义很多个具体建造类来实现这种变化。

Singleton单例模式为⼀个⾯向对象的应⽤程序提供了对象唯⼀的访问点，不管它实现何种功能，此种模式都为设计及开发团队提供了共享的概念。

然⽽，Singleton对象类派⽣⼦类就有很⼤的困难，只有在⽗类没有被实例化时才可以实现。

值得注意的是，有些对象不可以做成Singleton，⽐如.net的数据库链接对象(Connection)，整个应⽤程序同享⼀个Connection对象会出现连接池溢出错误。

另外，.net提供了⾃动废物回收的技术，因此，如果实例化的对象长时间不被利⽤，系统会认为它是废物，⾃动消灭它并回收它的资源，下次利⽤时⼜会重新实例化，这种情况下应注意其状态的丢失。

Command（命令模式）Command（命令模式）属于行为型模式。

意图：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。

举例子如果看不懂上面的意图介绍，没有关系，设计模式需要在日常工作里用起来，结合例子可以加深你的理解，下面我准备了三个例子，让你体会什么场景下会用到这种设计模式。

点菜是命令模式为什么顾客会找服务员点菜，而不是直接冲到后厨盯着厨师做菜？因为做菜比较慢，肯定会出现排队的现象，而且有些菜可能是一起做效率更高，所以将点菜和做菜分离比较容易控制整体效率。

其实这个社会现象就对应编程领域的命令模式：点菜就是一个个请求，点菜员记录的菜单就是将请求生成的对象，点菜员不需要关心怎么做菜、谁来做，他只要把菜单传到后厨即可，由后厨统一调度。

大型软件系统的操作菜单大型软件操作系统都有一个特点，即软件非常复杂，菜单按钮非常多。

但由于菜单按钮本身并没有业务逻辑，所以通过菜单按钮点击后触发的业务行为不适合由菜单按钮完成，此时可利用命令模式生成一个或一系列指令，由软件系统的实现部分来真正执行。

浏览器请求排队浏览器的请求不仅会排队，还会取消、重试，因此是个典型的命令模式场景。

如果不能将window.fetch序列化为一个个指令放入到队列中，是无法实现请求排队、取消、重试的。

意图解释意图：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。

一个请求指的是来自客户端的一个操作，比如菜单按钮点击。

重点在点击后并不直接实现，而是将请求封装为一个对象，可以理解为从直接实现：function onClick() {// ... balabala 实现逻辑}改为生成一个对象，序列化这个请求：function onClick() {concreteCommand.push({// ... 描述这个请求})// 执行所有命令队列concreteCommand.executeAll()}看上去繁琐了一些，但得到了后面所说的好处：“从而使你可用不同的请求对客户进行参数化”，也就是可以对任何请求进行参数化存储，我们可以在任意时刻调用。

23种设计模式范文设计模式是软件开发中常用的解决方案模式，它们代表了在面对特定问题时的最佳实践和经验总结。

设计模式可以帮助我们更好地组织和设计代码，提高代码的可读性、可维护性和可扩展性。

在本文中，我们将介绍23种常用的设计模式，并分别讨论它们的实现原理和在实际开发中的应用场景。

1. 单例模式（Singleton Pattern）单例模式是最简单的设计模式之一，它确保一个类只有一个实例，并提供一个全局访问点。

在实现上，可以通过将构造函数私有化，然后提供一个静态方法返回实例来实现单例。

应用场景：在需要实现全局唯一访问点的场景下，比如线程池、配置管理器等。

2. 工厂模式（Factory Pattern）工厂模式是用来创建对象的一种模式，它将对象的创建和实现分离，使得代码更易于维护和扩展。

工厂模式有简单工厂模式、工厂方法模式和抽象工厂模式等几种不同的变体。

应用场景：在需要根据不同条件创建不同对象的场景下，比如数据库连接、日志记录等。

3. 抽象工厂模式（Abstract Factory Pattern）抽象工厂模式是工厂模式的一种扩展，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定实际的类。

抽象工厂模式将一组工厂类封装起来，使其可以交换或者替换。

应用场景：在需要创建一组相关对象（如界面主题、操作系统等）并且需要保持一致性的场景下。

4. 建造者模式（Builder Pattern）建造者模式是用来生成复杂对象的一种模式，它将对象的构建与其表现分离，采用逐步构建的方式生成对象，可以让客户端不需要知道具体的构建细节。

应用场景：在构造过程比较复杂，需要多个组件协同工作的场景下，比如构建复杂的UI界面。

5. 原型模式（Prototype Pattern）原型模式是用来克隆对象的一种模式，它通过复制已有对象的原型来创建新的对象，避免了通过构造函数创建对象和初始化成员变量的重复过程。

应用场景：在需要创建大量相似对象或者初始化成本较高的对象时，可以使用原型模式。

23种设计模式记忆口诀
1.单例模式：唯一实例化，静态访问，线程不安全
2. 工厂方法模式：子类实现，工厂创建，扩展性强
3. 抽象工厂模式：创建一族产品，接口约束，扩展性强
4. 建造者模式：组合复杂对象，分步骤构建，灵活性高
5. 原型模式：克隆对象，避免重复创建，效率高
6. 适配器模式：兼容接口不同，类似转换器，易扩展
7. 桥接模式：抽象与实现分离，解耦合，易扩展
8. 装饰器模式：动态增强对象功能，不影响原有对象，易扩展
9. 组合模式：层次结构，统一访问，易扩展
10. 外观模式：简化复杂系统调用，易使用，易扩展
11. 享元模式：共享资源，避免重复创建，效率高
12. 代理模式：增强对象功能，控制对象访问，易扩展
13. 责任链模式：多个对象处理请求，自动传递，易扩展
14. 命令模式：将请求封装成对象，易扩展，易记录日志
15. 解释器模式：解释语言，易扩展，易维护
16. 迭代器模式：遍历集合，统一访问，易扩展
17. 中介者模式：分离对象间交互，降低耦合，易扩展
18. 观察者模式：对象状态改变，通知观察者，易扩展
19. 备忘录模式：保存对象状态，易恢复，易扩展
20. 状态模式：对象状态改变，自动改变行为，易扩展
21. 策略模式：选择不同策略，易切换，易扩展
22. 模板方法模式：定义操作流程，易扩展，易维护
23. 访问者模式：统一访问集合中对象，易扩展，易维护。

命令模式是对命令的封装。

通过封装把发出命令的责任和执行命令的责任分割开，委派给不同的对象。

命令（Command）模式属于对象的行为模式【GOF95】，它又称为行动（Action）模式或交易（Transaction）模式。

每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。

命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。

命令模式涉及到五个角色，它们分别是：1、客户（Client）角色：创建了一个具体命令(ConcreteCommand)对象并确定其接收者。

2、命令（Command）角色：声明了一个给所有具体命令类的抽象接口。

这是一个抽象角色。

3、具体命令（ConcreteCommand）角色：定义一个接受者和行为之间的弱耦合；实现Exec ute()方法，负责调用接收考的相应操作。

Execute()方法通常叫做执方法。

4、请求者（Invoker）角色：负责调用命令对象执行请求，相关的方法叫做行动方法。

5、接收者（Receiver）角色：负责具体实施和执行一个请求。

任何一个类都可以成为接收者，实施和执行请求的方法叫做行动方法。

代码实现：根据命令（Command）角色所要负责的工作，我们可分为两种方式来实现：1、一种是Seperate方式，此方式下命令（Command）角色仅确定一个接收者和执行该请求的动作，因此，它需要在子类中完成具体的命令操作，并通过请求者（Invoker）角色这一中间层来与接收者互动。

2、另一种是Combine方式，此时命令（Command）角色要自己实现所有命令功能，根本不需要请求者（Invoker）角色，它自己充当了中间层来与接收者互动。

下面我们来用代码说明如何理解Command命令模式,程序如下图:一、传统的做法：不采用Command模式的情况1、定义一个类Carusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace CommandCar{//一个类是一组操作和相应的一些变量的集合，现在有这样一个类Car，它有如下的一些操作public class Car{public string curStateStr;public Car(){curStateStr = "";}public void Start(){Console.WriteLine("车子起动");}public void MoveForwards(){Console.WriteLine("车子前进");}public void MoveBackwards(){Console.WriteLine("车子倒退");}public void Stop(){Console.WriteLine("车子停止");}}}2、使用这个类及其相关操作,写在Programme.cs中#region通常的操作(紧耦合方式)//通常的操作使得行为的请求者和行为的实现者之间呈现一种紧耦合,如果我们要对相关操作进行Redo，Undo等操作则这种紧耦合方式就显得很复杂//可以看到，客户程序是依赖于具体Car的命令（方法）的，引入Command 模式，需要对Car中的4个命令进行抽象//在抽象前，在我们看来Start(),MoveForwards(),MoveBackwards(), Stop()这几个方法都应该是Car所具有的，//如果单独抽象出来成一个命令对象，那就是把函数层面的功能提到了类的层面Car mycar = new Car();Console.WriteLine("--------常规方式执行效果如下----------"); mycar.Start();mycar.MoveForwards();mycar.MoveBackwards();mycar.Stop();// Console.ReadLine();#endregion这种情况下，把命令的接收者Car与行为(Start,Stop等操作)紧密耦合二、Seperate方式仍使用上面定义的类Car(它就是接收者Receiver角色),不同的是我们要加入以下角色1、命令Command角色CarSeperateCommandusing System;using System.Collections.Generic;using System.Linq;using System.Text;namespace CommandCar{//定义抽象类CarSeperateCommand，对于Function方式而言，它仅确定一个接收者Car和执行该请求的动作Excute。

23种设计模式总结设计模式是一种解决反复出现的设计问题的方案，它们被广泛应用于软件设计和架构中。

在这里，我们列举了23种常用的设计模式，分别属于创建型、结构型和行为型模式。

一、创建型模式1. 工厂方法模式（Factory Method Pattern）定义一个创建对象的接口，但让子类决定实例化哪个类。

工厂方法模式是让类来进行对象的创建，而不是由你的代码直接new 出来。

2. 抽象工厂模式（Abstract Factory Pattern）提供一个接口，用于创建一系列相关或相互依赖的对象。

3. 单例模式（Singleton Pattern）确保一个类只有一个实例，并提供一个全局访问点。

4. 建造者模式（Builder Pattern）将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

5. 原型模式（Prototype Pattern）用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

二、结构型模式6. 适配器模式（Adapter Pattern）将一个类的接口转换成客户希望的另外一个接口。

适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。

7. 桥接模式（Bridge Pattern）将抽象部分与它的实现部分分离，使它们都可以独立地变化。

8. 组合模式（Composite Pattern）将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

9. 装饰器模式（Decorator Pattern）动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器比生成子类更为灵活。

10. 外观模式（Facade Pattern）为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，使得这一子系统更加容易使用。

11. 享元模式（Flyweight Pattern）运用共享技术有效地支持大量细粒度的对象。