设计模式实验——命令模式

合集下载

设计模式—命令模式

设计模式—命令模式
setCommand()
Command
create Command Object()
Client
action1() action2() ……
execute()
Command
Receiver
从餐厅到命令模式
Command execute()
Client Receiver Invoker setCommand()
使用命令对象
public class SimpleRemoteControl{ Command slot; public SimpleRemoteControl(){} public void setCommand(Command command){ slot=command; } public void buttonWaspressed(){ slot. execute(); } }
execute() undo()
public void execute(){ Receiver.action() }
定义命令模式
Client
具体的命令中定义了动作和接收者之 间的绑定关系。调用者只要调用 execute()就可以发出请求,由命令调 setCommand() execute() 用接收者的一个或多个动作。
Command
定义命令模式
Client
Invoker
setCommand()
《interface 》 Command
execute() undo()
Receiver
action()
ConcreteCommand
execute() undo()
public void execute(){ Receiver.action() }

设计模式—之命令

设计模式—之命令

一个具体的例子
//烤鸡翅命令 class bakemuttoncommand: command { public bakemuttoncommand(barbecuerman receiver):command(receiver) { } public void excutecommand() {receiver.bakechikenwing();} }

一个具体的例子

客户端:
void main() { //准备工作 Barbecuer boy=new barbecuerman(); Command bakemuttoncommand1=new bakemuttoncommand(boy); Command bakechickenwingcommand1=new bakechickenwingcommand(boy); waiter girl=new waiter();

一个具体的例子
具体命令类 //烤羊肉串命令、执行具体的行为 class bakemuttoncommand: command { public bakemuttoncommand(barbecuerman receiver):command(receiver) { } public void excutecommand() {receiver.bakemutton();} }
烧烤店事先准备好了厨师和服 务员,等着开业
一个具体的例子
//开门营业 girl.setorder(bakemuttoncommand1); girl.notify(); girl.setorder(bakechichenwingcommand1); girl.notify(); }

一个具体的例子

设计模式学习总结:命令模式

设计模式学习总结:命令模式

设计模式学习总结:命令模式问题:在面向对象的软件设计中,经常会遇到一个(或一系列)对象,对象本身的数据存储与对象的操作耦合在一起。

例如一个对象有 add(),edit(),delete()方法,这样对象支持的方法很难扩展,如果需要加入update()就必须修改代码,客户端与对象也是紧耦合的。

命令模式是将一类对象的功能(行为,功能)抽象成一个命令对象,客户端在使用的时候,只与该命令对象打交道,而不用与对象打交道,分离命令的请求者和命令的执行者,降低了耦合性,可以使用不同的请求对客户进行参数化提高了程序设计的灵活性。

定义:命令模式(Command)模式,将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤消的操作。

意图:提供一个抽象的Command接口,将执行命令操作的方法封装到Command类接口中,ConcreteCommand实现这个Command接口方法,通过调用Receiver实例变量处理请求。

客户端定义一个Invoker对象存储该concreteCommand对象,该invoker通过调用command对象递交一个请求。

参与者:•抽象命令角色(Command):定义命令的接口,声明执行的方法。

具体命令角色(ConcreteCommand):命令接口实现对象,是“虚”的实现;通常会持有接收者,并调用接收者的功能来完成命令要执行的操作。

•请求者(Invoker):要求命令对象执行请求,通常会持有命令对象,可以持有很多的命令对象。

这个是客户端真正触发命令并要求命令执行相应操作的地方,也就是说相当于使用命令对象的入口。

•接收者(Receiver、执行者):接收者,真正执行命令的对象。

任何类都可能成为一个接收者,只要它能够实现命令要求实现的相应功能。

•客户端(Client):创建具体的命令对象,并且设置命令对象的接收者。

注意这个不是我们常规意义上的客户端,而是在组装命令对象和接收者,或许,把这个Client称为装配者会更好理解,因为真正使用命令的客户端是从Invoker来触发执行。

c++设计模式:命令模式(CommandPattern)

c++设计模式:命令模式(CommandPattern)

c++设计模式:命令模式(CommandPattern)定义:命令模式将“请求”封装成对象,以便使⽤不同的请求、队列或者⽇志来参数化其他对象,命令模式也⽀持可撤销的操作。

命令模式可将“动作的请求者”从“动作的执⾏者”对象中解耦。

场景:我们要设计⼀个遥控器,可以通过按动上边的控制按钮控制卧室和厨房的灯,还能控制卧室中的⾳响的开关。

遥控器及时我们的“动作的请求者”,⽽灯和⾳响就是我们的“动作的执⾏者”。

当我们按动遥控器上的某个开关后,遥控器就可以把相关的指令发送到我们的指定的家电上。

这之中遥控器和家电之间是解耦的,我们完全可以通过设置,添加、修改或删除其它的家电控制功能,⽽不需要修改遥控器的代码。

类图:c++代码如下:#include <iostream>#include <vector>using namespace std;class Command{public:virtual void execute() = 0;};class NoCommand : public Command{public:void execute() {};};class Light{public:Light(string location);void on();void off();private:string m_sLocation;};class LightOffCommand : public Command{public:LightOffCommand(string location):m_Light(location) {}void execute();private:Light m_Light;};class LightOnCommand : public Command{public:LightOnCommand(string location):m_Light(location) {}void execute();private:Light m_Light;};class Stereo{public:Stereo(string location);void on();void off();void setCD();void setDVD();void setRadio();void setVolume(int volume);private:string m_sLocation;};class StereoOnWithCDCommand : public Command{public:StereoOnWithCDCommand(string location):m_Stereo(location) {}void execute();private:Stereo m_Stereo;};class StereoOffCommand : public Command{public:StereoOffCommand(string location):m_Stereo(location) {}void execute();private:Stereo m_Stereo;};class RemoteControl{public:RemoteControl();~RemoteControl();void setCommand(int slot, Command* pOnCommand, Command* pOffCommand); void onButtonWasPushed(int slot);void offButtonWasPushed(int slot);private:vector<Command*> m_OnCommands;vector<Command*> m_OffCommands;};Light::Light(string location){m_sLocation = location;}void Light::on(){printf("%s light is on\n",m_sLocation.c_str());}void Light::off(){printf("%s light is off\n",m_sLocation.c_str());}void LightOffCommand::execute(){m_Light.off();}void LightOnCommand::execute(){m_Light.on();}Stereo::Stereo(string location){m_sLocation = location;}void Stereo::on(){printf("%s stereo is on\n",m_sLocation.c_str());}void Stereo::off(){printf("%s stereo is off\n",m_sLocation.c_str());}void Stereo::setCD(){printf("%s stereo is set for CD input\n",m_sLocation.c_str());}void Stereo::setDVD(){printf("%s stereo is set for DVD input\n",m_sLocation.c_str());}void Stereo::setRadio(){printf("%s stereo is set for Radio\n",m_sLocation.c_str());}void Stereo::setVolume(int volume){printf("%s Stereo volume set to %d\n",m_sLocation.c_str(),volume);}void StereoOnWithCDCommand::execute(){m_Stereo.on();m_Stereo.setCD();m_Stereo.setVolume(11);}void StereoOffCommand::execute(){m_Stereo.off();}RemoteControl::RemoteControl(){for (int i = 0; i < 7; i++){Command* noCommandOn = new NoCommand();m_OnCommands.push_back(noCommandOn);Command* noCommandOff = new NoCommand();m_OffCommands.push_back(noCommandOff);}}RemoteControl::~RemoteControl(){for (int i = 0; i < 7; i++){delete m_OnCommands.at(i);delete m_OffCommands.at(i);}m_OnCommands.clear();m_OffCommands.clear();}void RemoteControl::setCommand(int slot, Command* pOnCommand, Command* pOffCommand){delete m_OnCommands.at(slot);m_OnCommands.at(slot) = pOnCommand;delete m_OffCommands.at(slot);m_OffCommands.at(slot) = pOffCommand;}void RemoteControl::onButtonWasPushed(int slot){m_OnCommands.at(slot)->execute();}void RemoteControl::offButtonWasPushed(int slot){m_OffCommands.at(slot)->execute();}int main(){RemoteControl remoteControl;LightOffCommand* pLivingRoomLightOff = new LightOffCommand("Living Room");LightOffCommand* pKitchenLightOff = new LightOffCommand("Kitchen");LightOnCommand* pLivingRoomLightOn = new LightOnCommand("Living Room");LightOnCommand* pKitchenLightOn = new LightOnCommand("Kitchen");StereoOnWithCDCommand* pStereoOnWithCD = new StereoOnWithCDCommand("Living Room"); StereoOffCommand* pStereoOff = new StereoOffCommand("Living Room");remoteControl.setCommand(0,pLivingRoomLightOn,pLivingRoomLightOff);remoteControl.setCommand(1,pKitchenLightOn,pKitchenLightOff);remoteControl.setCommand(2,pStereoOnWithCD,pStereoOff);remoteControl.onButtonWasPushed(0);remoteControl.offButtonWasPushed(0);remoteControl.onButtonWasPushed(1);remoteControl.offButtonWasPushed(1);remoteControl.onButtonWasPushed(2);remoteControl.offButtonWasPushed(2);return0;}运⾏结果如下:Living Room light is onLiving Room light is offKitchen light is onKitchen light is offLiving Room stereo is onLiving Room stereo is set for CD input Living Room Stereo volume set to 11 Living Room stereo is off参考图书:《Head First 设计模式》。

设计模式——命令模式(指令模式)

设计模式——命令模式(指令模式)

设计模式——命令模式(指令模式)也是在看到阿⾥巴巴的⾯试题的时候总结的作者:haibiscuit时间:2019:3:13您的star是我不断前⾏的动⼒转载请说明出处七:命令模式(指令模式)定义:将⼀个请求封装成⼀个对象,从⽽让你可以⽤不同的请求对客户进⾏参数化,对请求排队或者记录请求⽇志,以及⽀持可撤销操作应⽤实例:可以参考Hystrix的实现⽅式,就是采⽤命令模式实现使⽤场景:可以将接受者的操作封装在命令类中,将命令类封装在调⽤者中,直接使⽤调⽤者,即可完成对操作者的操作,可以解决解耦和的作⽤public class CommandMode {public static void main(String []args){Command command; //命令对象command = new ExitCommand();FunctionButton functionButton = new FunctionButton(command);functionButton.click(); //即在调⽤者调⽤时,命令对象操作接受者}}/*** 调⽤者*/class FunctionButton{private Command command;public FunctionButton(Command command){ //构造注⼊mand = command;}public Command getCommand() {return command;}public void setCommand(Command command) {mand = command;}public void click(){ //调⽤命令类的⽅法command.Execute();}}/*** 抽象命令类*/abstract class Command{abstract void Execute();}class ExitCommand extends Command{private SystemExitClass seObj;public ExitCommand(){this.seObj = new SystemExitClass();}@Overridevoid Execute() {seObj.Exit();}}/*** 接收者*/class SystemExitClass{ //退出系统模拟实现类public void Exit(){System.out.println("退出系统!");}}总结:命令模式是⼀种⾏为型模式,⾸先要了解⾏为的执⾏模型:调⽤者->命令类->接受者也就是,调⽤者间接地通过命令类来操作接受者,这⾥可以通过拓展命令类的⽅式来完成对接受者的操作(例如上⾯的实例中,可以通过点击按钮(调⽤者)实现其他对接受者的功能,例如退出系统(已实现),打开⽂档,可以将打开⽂档的⾏为封装在接受者中,通过拓展命令类的⽅式(这⾥可以实现⼀个OpenDocuCommand的命令类)来完成对接收者的操作。

设计模式Command_命令模式

设计模式Command_命令模式

Command(命令模式)Command(命令模式)属于行为型模式。

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

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

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

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

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

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

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

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

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

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

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

命令模式设计实验报告(3篇)

命令模式设计实验报告(3篇)

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

2. 掌握命令模式的结构和实现方法。

3. 通过实际案例分析命令模式在软件开发中的应用。

4. 提高对设计模式在实际项目中的应用能力。

二、实验环境1. 开发工具:IntelliJ IDEA2. 开发语言:Java3. 操作系统:Windows 10三、实验内容本次实验以餐厅点餐系统为例,设计并实现命令模式,模拟餐厅服务员接单、传单、下单等操作。

1. 定义角色(1)Command(抽象命令类):定义执行命令的接口,包括执行操作和撤销操作。

(2)ConcreteCommand(具体命令类):实现抽象命令类,封装具体操作,并设置接收者对象。

(3)Invoker(调用者):持有命令对象,并在需要时调用命令对象的执行和撤销操作。

(4)Receiver(接收者):知道如何执行与某个请求相关的操作。

(5)Client(客户端):客户端负责创建命令对象,并设置调用者。

2. 实现命令模式(1)定义抽象命令类```javapublic interface Command {void execute();void undo();}```(2)定义具体命令类```javapublic class OrderCommand implements Command { private Receiver receiver;public OrderCommand(Receiver receiver) { this.receiver = receiver;}@Overridepublic void execute() {receiver.order();}@Overridepublic void undo() {receiver.undoOrder();}}```(3)定义接收者```javapublic class Receiver {public void order() {System.out.println("下单成功!");}public void undoOrder() {System.out.println("订单已撤销!"); }}```(4)定义调用者```javapublic class Invoker {private Command command;public void setCommand(Command command) { mand = command;}public void action() {command.execute();}public void undoAction() {command.undo();}}```(5)客户端创建命令对象并设置调用者```javapublic class Client {public static void main(String[] args) {Receiver receiver = new Receiver();Command command = new OrderCommand(receiver);Invoker invoker = new Invoker();invoker.setCommand(command);invoker.action(); // 执行命令invoker.undoAction(); // 撤销命令}}```3. 实验结果通过以上代码,我们成功实现了餐厅点餐系统的命令模式。

研磨设计模式之命令模式

研磨设计模式之命令模式

研磨设计模式之命令模式命令模式也是开发中常见的一个模式,也不是太难,比较简单,下面来详细的写一下命令模式。

命令模式(Command)1 场景问题1.1 如何开机估计有些朋友看到这个标题会非常奇怪,电脑装配好了,如何开机?不就是按下启动按钮就可以了吗?难道还有什么玄机不成。

对于使用电脑的客户——就是我们来说,开机确实很简单,按下启动按钮,然后耐心等待就可以了。

但是当我们按下启动按钮过后呢?谁来处理?如何处理?都经历了怎样的过程,才让电脑真正的启动起来,供我们使用。

先一起来简单的认识一下电脑的启动过程,了解一下即可。

●当我们按下启动按钮,电源开始向主板和其它设备供电●主板的系统BIOS(基本输入输出系统)开始加电后自检●主板的BIOS会依次去寻找显卡等其它设备的BIOS,并让它们自检或者初始化●开始检测CPU、内存、硬盘、光驱、串口、并口、软驱、即插即用设备等等● BIOS更新ESCD(扩展系统配置数据),ESCD是BIOS和操作系统交换硬件配置数据的一种手段●等前面的事情都完成后,BIOS才按照用户的配置进行系统引导,进入操作系统里面,等到操作系统装载并初始化完毕,就出现我们熟悉的系统登录界面了。

1.2 与我何干讲了一通电脑启动的过程,有些朋友会想,这与我何干呢?没错,看起来这些硬件知识跟你没有什么大的关系,但是,如果现在提出一个要求:请你用软件把上面的过程表现出来,你该如何实现?首先把上面的过程总结一下,主要就这么几个步骤:首先加载电源,然后是设备检查,再然后是装载系统,最后电脑就正常启动了。

可是谁来完成这些过程?如何完成?不能让使用电脑的客户——就是我们来做这些工作吧,真正完成这些工作的是主板,那么客户和主板如何发生联系呢?现实中,是用连接线把按钮连接到主板上的,这样当客户按下按钮的时候,就相当于发命令给主板,让主板去完成后续的工作。

另外,从客户的角度来看,开机就是按下按钮,不管什么样的主板都是一样的,也就是说,客户只管发出命令,谁接收命令,谁实现命令,如何实现,客户是不关心的。

设计模式学习笔记-命令模式

设计模式学习笔记-命令模式

mand模式------命令模式1.1. 定义命令模式将请求封装成对象,以便使用不同的请求、队列或日志来参数化其他对象。

命令模式也支持科撤销的操作。

1.2. 优点与缺点1.1.1优点提供了用统一方法执行不同行为的简单机制。

允许在运行时改变所处理的请求,以及如何处理请求。

仅仅需要很少的代码实现。

1.1.2缺点当条件调度程序已经足够的时候,会增加设计的复杂度。

1.3. UML图1.4. UML例子图1.1.3用Command替换条件调度1.1.4《head first设计模式》Command例子类图1.5. 要点●命令模式将发出请求的对象和执行请求的对象解耦。

●在被解耦的两者之间是通过命令对象进行沟通的。

命令对象封装了接收者和一个或一组动作。

●调用者通过调用命令对象的execute()发出请求,这会使得接收者的动作被调用。

●调用者可以接受命令当做参数,甚至在运行时动态地进行。

●命令可以支持撤销,做法是实现一个undo()方法来回到execute()被执行前的状态。

●宏命令是命令的一种简单的延伸,允许调用多个命令。

宏方法也可以支持撤销。

●实际操作时,很常见使用“聪明”命令对象,也就是直接实现了请求,而不是将工作委托给接受者。

命令也可以用来实现日志和事务系统。

1.6. 动机许多系统都会收到、发送并处理请求。

条件调度程序是一条条件语句,它用来执行请求的发送和处理。

有些条件调度程序很适合它们要完成的任务。

有些则并不适合。

适合任务的条件调度程序往往只是把少量的请求发送到少量的处理逻辑中。

这种调度程序的代码往往可以在一屏内显示,我们不需要滚动屏幕。

通常情况下,用Command模式替换这种条件调度程序并没有什么益处。

另一方面,即使条件调度程序很小,它也可能不适合你的系统。

把条件调度程序重构为基于Command的解决方案,有两个最常见的理由。

1)缺少足够的运行时灵活性。

依赖于条件调度程序的客户代码需要用新的请求或处理逻辑动态的配置这个条件调度程序。

设计模式之命令模式

设计模式之命令模式

设计模式之命令模式定义将⼀个请求封装为⼀个对象,从⽽使你可⽤不同的请求对客户进⾏参数化,对请求排队或记录请求⽇志,以及⽀持可撤销的操作。

可以类⽐现实⽣活中我们使⽤电视遥控器开关机,或者去餐厅吃饭向服务员点餐的过程,⽤户不需要知道点的菜是具体哪个厨师做的,厨师也不需要知道这个菜是哪个⽤户点的,命令发送者和执⾏者之间解耦。

结构Command,命令接⼝,定义执⾏的⽅法。

ConcreteCommand,具体命令,拥有接收者对象,调⽤接收者的功能来完成命令要执⾏的操作。

Receiver,接收者,真正执⾏命令的对象。

Invoker,调⽤者,是请求的发送者,通常会拥有很多命令对象,并通过访问命令对象来执⾏相关请求。

Client,客户端,也可以称为装配者,组装命令对象和接收者,并触发执⾏。

以⽤户餐厅点餐为例,⽤户就是客户端,服务员就是调⽤者,点餐就是命令,厨师就是接收者。

简单实现命令接⼝public interface Command {void execute();}具体命令public class ConcreteCommand implements Command {private Receiver receiver;public ConcreteCommand(Receiver receiver) {this.receiver = receiver;}@Overridepublic void execute() {receiver.action();}}接收者/*** 命令接收者*/public class Receiver {public void action() {System.out.println("Receiver the command and execute");}}调⽤者public class Invoker {private Command command;public Invoker(Command command) {mand = command;}public void runCommand() {command.execute();}}客户端public class Client {public static void main(String[] args) {//组装命令和执⾏者Receiver receiver = new Receiver();Command command = new ConcreteCommand(receiver);Invoker invoker = new Invoker(command);invoker.runCommand();}}命令的撤销和恢复命令模式的关键之处就是将请求封装成对象,也就是命令对象,并定义了统⼀的执⾏操作的接⼝,这个命令对象可以被存储,转发,记录,处理,撤销等,整个命令模式都是围绕这个对象在进⾏。

设计模式——命令模式

设计模式——命令模式
}
public void buttonWasPressed(){ command.execute();
} } public class Client {
public static void main(String[] args) { Light light = new Light("room"); LightOnCommand command = new LightOnCommand(light); Invoker invoker = new Invoker(command); invoker.buttonWasPressed();
} }
public interface Command { void execute(); void undo();
}
public class LightOnCommand implements Command {
private Light light;
public LightOnCommand(Light light){ this.light = light;
网络错误503请刷新页面重试持续报错请尝试更换浏览器或网络环境
设计模式 ——命令模式
一、定义
1、 定 义
创建一个命令对象来代表实际行动。命令对象可以把行动(action) 及其参数封装起来,于是这些行动可以被: 重复多次 取消 取消后又再重做
这些都是现代大型应用程序所必须的功能,即“撤销”及“重复”。除此之外,可以用命令模式来实现的功能例子还有: 交易行为 进度列 向导 用户界面按钮及功能表项目 线程 pool 宏收录
}
@Override public void execute() {
light.on(); }

设计模式之命令模式

设计模式之命令模式

设计模式之命令模式 在许多设计中,经常设计⼀个对象请求另⼀个对象执⾏某⼀个操作。

如果请求者⽆法或者不希望直接和被请求者打交道,即请求对象⽆法或者不希望含有被请求者的引⽤,那么可以使⽤命令模式。

命令模式⾥称提出请求的对象为请求者,被请求者的对象为接收者。

在命令模式中,当⼀个对象请求另⼀个对象调⽤其⽅法时,不和被请求者直接打交道,⽽是把这种“请求”封装到⼀个“命令”对象中,封装的⼿段将“请求”封装到“命令”对象的⼀个⽅法中。

命令模式的核⼼就是使⽤命令对象来封装⽅法调⽤。

例如,在军队作战时,指挥官要命令三连偷袭敌⼈。

但是指挥官这时⽆法或者不希望和三连直接取得联系,那么指挥官可以发出⼀个命令,把该命令的执⾏者设置为三连。

这样指挥官只要和命令打交道。

命令模式包含四种⾓⾊: 接收者:接收者是⼀个类的实例,该实例负责执⾏与请求相关的操作。

命令接⼝:命令式⼀个接⼝,规定了⽤来封装“请求”的若⼲个⽅法,⽐如execute()、undo()等⽅法。

具体命令:具体命令式实现了命令接⼝的类的实例,包含命令接⼝的⽅法。

并且包含接受者的引⽤,指明那个对象去执⾏该命令。

请求者:请求者是包含命令接⼝变量类的实例,该接⼝变量可以存放任何具体命令的引⽤。

请求者负责调⽤具体命令,让具体命令执⾏那些封装了的请求⽅法。

下⾯看军队作战的例⼦: 1.命令接收者:1package mand;2//命令接收者、执⾏者3public class CompanyArmy {4public void sneakAttack(){5 System.out.println("我们知道如何袭击敌⼈,保证完成任务");6 }7 } 2.命令接⼝:1package mand;2//命令接⼝3public interface Command {4void execute();5 } 3.具体命令:1package mand;2//具体命令3public class ConcreteCommand implements Command{4 CompanyArmy army; //含有接收者的引⽤5public ConcreteCommand(CompanyArmy army) {6this.army = army;7 }8public void execute() { //封装着指挥官的请求9 army.sneakAttack(); //偷袭敌⼈10 }11 } 4.请求者:1package mand;2//请求者,也就是命令发送者3public class ArmySuperior {4 Command command; //存放具体命令的引⽤5public void setCommand(Command command){mand = command;7 }8public void startExecuteCommand(){9 command.execute();10 }11 } 命令模式所需要的四个⾓⾊已经建⽴好了,下⾯测试⼀下:1package mand;23public class Application {4public static void main(String[] args) {5 CompanyArmy army = new CompanyArmy(); //创建命令接收者6 Command command = new ConcreteCommand(army);//创建⼀个具体命令并且指定接收者7 ArmySuperior superior = new ArmySuperior(); //创建命令请求者8 superior.setCommand(command); //给请求者设置⼀个具体命令9 superior.startExecuteCommand(); //开始执⾏命令10 }11 } 这样就可以实现指挥官不直接和命令执⾏者,只需要发送⼀个命令,该命令就会找到指定的执⾏者去执⾏。

设计模式:命令(Command)模式

设计模式:命令(Command)模式

设计模式:命令(Command)模式设计模式:命令(Command)模式⼀、前⾔命令也是类,将命令作为⼀个类来保存,当要使⽤的时候可以直接拿来使⽤,⽐如脚本语⾔写出的脚本,只需要⼀个命令就能执⾏得到我们想要的需要操作很长时间才能得到的结果。

这是⼀个⾮常有意思的模式,将操作的步骤保存下来,本例之中我们使⽤java⾃带的GUI来画图,然后将画图的过程(在哪个地⽅画了什么东西)保存下来,可以把每⼀次我们的操作作为⼀个命令,其实就是<使⽤什么画布,画点的坐标>,将这个命令对应的对象保存到所有命令对象的集合之中去,这样命令集合就记录下来了每⼀个命令,如果要显⽰画的内容的时候,直接将这些命令组合读取出来在进⾏⼀次重画即可。

通过这种模式保存下来已经执⾏的步骤,通过重画再复述出来,是⼀种⾮常重要的开发理念,在需要保存历史纪录并恢复的场合是⾮常有⽤的。

⼆、代码Command接⼝:1package mand;23public interface Command {4public abstract void execute();5 }DrawCommand类:1package mand;23import java.awt.Point;456public class DrawCommand implements Command {78private Drawable drawable;9private Point position;10public DrawCommand(Drawable drawable,Point position){11this.drawable=drawable;12this.position=position;13 }1415public void execute() {16 drawable.draw(position.x, position.y);17 }1819 }MacroCommand 类:3import java.util.Iterator;4import java.util.Stack;56public class MacroCommand implements Command { 78 Stack commands=new Stack();910public void execute() {11 Iterator it = commands.iterator();12while(it.hasNext()){13 Command command=(Command)it.next();14 command.execute();15 }16 }1718public void append(Command command){19if(command!=this){20 commands.add(command);21 }22 }2324public void clear(){25 commands.clear();26 }2728public void undo(){29if(!commands.isEmpty()){30 commands.pop();31 }32 }3334 }Drawable接⼝:1package mand;23public interface Drawable {45public abstract void draw(int x,int y);67 }DrawCanvas 实现类:3import java.awt.*;4import java.util.Random;567public class DrawCanvas extends Canvas implements Drawable {89private static final long serialVersionUID = 1972130370393242746L;1011private MacroCommand history;12private int radius=8;1314public DrawCanvas(int width,int hieght, MacroCommand history){15 setSize(width,hieght);16 setBackground(Color.white);17this.history=history;18 }1920public void draw(int x, int y) {21 Random random = new Random();2223 Graphics g = getGraphics();24 g.setColor((random.nextBoolean())? Color.yellow : Color.MAGENTA);25 g.fillOval(x-radius, y-radius, radius*2, radius*2);26 }2728 @Override29public void paint(Graphics g) {30 System.out.println("执⾏⼀次刷新!"+System.currentTimeMillis());31 history.execute();32 }3334 }Main类:1package mand;23import java.awt.event.ActionEvent;4import java.awt.event.ActionListener;5import java.awt.event.MouseEvent;6import java.awt.event.MouseMotionListener;7import java.awt.event.WindowEvent;8import java.awt.event.WindowListener;910import javax.swing.*;111213public class Main extends JFrame implements ActionListener,MouseMotionListener,WindowListener{ 1415private MacroCommand history=new MacroCommand() ;1617private JButton btnClear=new JButton("清除");18private JButton btnRePaint=new JButton("重现");1920private DrawCanvas canvas=new DrawCanvas(400,400,history);2122public Main(String title){23super(title);2425this.addWindowListener(this);26 canvas.addMouseMotionListener(this);27 btnClear.addActionListener(this);28 btnRePaint.addActionListener(this);2930 Box btnBox=new Box(BoxLayout.X_AXIS);31 btnBox.add(btnClear);32 btnBox.add(btnRePaint);3334 Box mainBox=new Box(BoxLayout.Y_AXIS);35 mainBox.add(btnBox);36 mainBox.add(canvas);3738 getContentPane().add(mainBox);3940 pack();41 show();42 }4344public static void main(String[] args) {4546new Main("命令模式");4748 }495051 @Override52public void actionPerformed(ActionEvent e) {53if(e.getSource()==btnClear){54 history.clear();55 canvas.repaint();56 }else if(e.getSource()==btnRePaint){57 canvas.repaint();58 }59 }606162 @Override63public void mouseDragged(MouseEvent e) {64 Command cmd=new DrawCommand(canvas,e.getPoint());65 history.append(cmd);66 cmd.execute();67 }6869 @Override70public void windowClosing(WindowEvent e) {71 System.exit(0);72 }7374757677 @Override78public void windowOpened(WindowEvent e) {79 }8081 @Override82public void windowClosed(WindowEvent e) {83 }8485 @Override86public void windowIconified(WindowEvent e) {87 }8889 @Override90public void windowDeiconified(WindowEvent e) {91 }9293 @Override94public void windowActivated(WindowEvent e) {95 }9697 @Override98public void windowDeactivated(WindowEvent e) {99 }100101 @Override102public void mouseMoved(MouseEvent e) {103 }104 }实验结果:由此我们可以看到保存了的命令就这样⼀个个的再次执⾏了⼀遍,是不是很有意思呢?!让我们分析⼀下程序执⾏的过程:1、开始执⾏初始化界⾯,然后显⽰:1public static void main(String[] args) {23 new Main("命令模式");45 }1public Main(String title){2super(title);34this.addWindowListener(this);5 canvas.addMouseMotionListener(this);6 btnClear.addActionListener(this);7 btnRePaint.addActionListener(this);89 Box btnBox=new Box(BoxLayout.X_AXIS);10 btnBox.add(btnClear);11 btnBox.add(btnRePaint);1213 Box mainBox=new Box(BoxLayout.Y_AXIS);14 mainBox.add(btnBox);15 mainBox.add(canvas);1617 getContentPane().add(mainBox);1819 pack();20 show();21 }2、然后等待⽤户的操作,当监听到⽤户在界⾯上拖动⿏标的时候,执⾏:1 @Override2 public void mouseDragged(MouseEvent e) {3 Command cmd=new DrawCommand(canvas,e.getPoint());4 history.append(cmd);5 cmd.execute();6 }3、创建⼀个命令对象,然后记录进命令堆栈之中,之后我们跟踪 cmd.execute();1package mand;23public interface Command {4public abstract void execute();5 }4、这⾥就看到我们的⾯向抽象编程的好处了,根本不需要知道是谁执⾏了我们的命令,在命令的时候⾃然知道了,那就是new DrawCommand(canvas,e.getPoint());我们继续跟踪:1public class DrawCommand implements Command {23。

设计模式实验0

设计模式实验0

实验1 命令模式的应用(必做)
1 实验目的
1) 掌握命令模式(Command)的特点 2) 分析具体问题,使用命令模式进行设计。

2 实验内容和要求
假设电视机有三个操作:开机(Open)、关机(Close)和换台(change channel),可以将其看作是命令。

电视机的遥控器相当于请求者(Invoker)的角色,操作者(Joe)相当于此系统的客户,电视机本身是命令的接受者。

请使用Java语言设计一个模拟系统,并给出设计图和源代码。

实验2 观察者模式的应用(选作)
1 实验目的
1) 掌握外观模式(Observer)的特点 2) 分析具体问题,使用外观模式进行设计。

2 实验内容和要求
网上商店中如果商品(product)在名称(name)、价格(price)等方面有变化,系统能自动通知会员,将是网上商店区别传统商店的一大特色。

如何设计实现?说明你所选择的设计模式,画出类关系图并指明各个类的角色。

应用外观模式,用JAVA控制台应用程序改进该设计。

【设计模式】——命令模式Commond

【设计模式】——命令模式Commond

【设计模式】——命令模式Commond 前⾔:【】——————————by xingoo 模式意图 将⼀个请求封装成⼀个对象,从⽽对这个命令执⾏撤销、重做等操作。

典型的Eclipse开发中,编辑器的操作就需要⽤到这个模式,⽐如Undo、Redo等等。

另外这个模式使得⼀个命令的触发与接收解耦,这样我们就可以演变成把感兴趣的对象接收这个命令,当命令触发时,这些对象就会执⾏操作。

这个机制也是java事件的处理⽅式。

应⽤场景 1 命令抽象成对象 2 在不同的时刻,指定或者排队命令 3 ⽀持 Undo或者Redo等操作 4 修改⽇志,当系统崩溃时,利⽤修改⽇志执⾏撤销 5 原语操作上构造⼀个⾼层系统(不理解) 模式结构 Invoker 命令的触发者,触发⼀个命令的执⾏。

/*** 命令的触发者,发送命令* @author xingoo**/class Invoker{private Commond commond;public Invoker(Commond commond) {mond = commond;}public void action(){commond.excute();}} Receiver 命令的接受者,针对命令,执⾏⼀定的操作。

/*** 命令的接受者,负责接收命令,进⾏处理* @author xingoo**/class Receiver{public Receiver() {}public void action(){System.out.println("Action of receiver!");}} Commond 命令的抽象接⼝/*** 命令接⼝,定义命令的统⼀接⼝* @author xingoo**/interface Commond{public void excute();} ConcreteCommond 具体的命令,关联⼀个接收者对象,当命令执⾏时,执⾏这个接收者对应的操作。

命令模式

命令模式

实验1:命令模式一、实验目的本实验要求学生掌握命令模式,要求学生理解命令模式中的四种角色并完成类的定义及测试。

二、实验任务1.在军队作战中,指挥官请求三连偷袭敌人,但是指挥官不希望或无法直接与三连取得联系。

使用命令模式分析有哪些类以及这些类的角色,完成这些类的定义并进行测试。

接收者:Receiver类命令接口:Command类具体命令:ConcreteCommand类请求者: Invoker类import ng.*;class Receiver{p ublic void sneakAttack(){System.out.println("I konw");}}interface Command{p ublic abstract void execute();}class ConcreteCommand implements Command{R eceiver army;C oncreteCommand(Receiver army){this.army = army;}p ublic void execute(){army.sneakAttack();}}class Invoker{C ommand command;p ublic void setCommand(Command command){mand = command;}p ublic void startExecuteCommand(){command.execute();}}public class Main {p ublic static void main(String [] args){Receiver thirdArmy = new Receiver();Command command = new ConcreteCommand(thirdArmy);Invoker superior = new Invoker();superior.setCommand(command);superior.startExecuteCommand();}}2.茱丽(Julia)不需要知道播音(play)、倒带(rewind)和停止(stop)功能是怎么具体执行的,这些命令执行的细节全都由键盘(Keypad)具体实施。

设计模式之命令模式

设计模式之命令模式

设计模式之命令模式1.智能⽣活项⽬需求看⼀个具体的需求我们买了⼀套智能家电,有照明灯、风扇、冰箱、洗⾐机,我们只要在⼿机上安装 app 就可以控制对这些家电⼯作。

这些智能家电来⾃不同的⼚家,我们不想针对每⼀种家电都安装⼀个 App,分别控制,我们希望只要⼀个 app 就可以控制全部智能家电。

要实现⼀个 app 控制所有智能家电的需要,则每个智能家电⼚家都要提供⼀个统⼀的接⼝给 app 调⽤,这时就可以考虑使⽤命令模式。

命令模式可将“动作的请求者”从“动作的执⾏者”对象中解耦出来.在我们的例⼦中,动作的请求者是⼿机 app,动作的执⾏者是每个⼚商的⼀个家电产品2 命令模式基本介绍命令模式(Command Pattern):在软件设计中,我们经常需要向某些对象发送请求,但是并不知道请求的接收者是谁,也不知道被请求的操作是哪个,我们只需在程序运⾏时指定具体的请求接收者即可,此时,可以使⽤命令模式来进⾏设计命名模式使得请求发送者与请求接收者消除彼此之间的耦合,让对象之间的调⽤关系更加灵活,实现解耦。

在命名模式中,会将⼀个请求封装为⼀个对象,以便使⽤不同参数来表⽰不同的请求(即命名),同时命令模式也⽀持可撤销的操作。

通俗易懂的理解:将军发布命令,⼠兵去执⾏。

其中有⼏个⾓⾊:将军(命令发布者)、⼠兵(命令的具体执⾏者)、命令(连接将军和⼠兵)。

Invoker 是调⽤者(将军),Receiver 是被调⽤者(⼠兵),MyCommand 是命令,实现了 Command 接⼝,持有接收对象。

命令模式的原理类图对原理类图的说明-即(命名模式的⾓⾊及职责)Invoker 是调⽤者⾓⾊Command: 是命令⾓⾊,需要执⾏的所有命令都在这⾥,可以是接⼝或抽象类Receiver: 接受者⾓⾊,知道如何实施和执⾏⼀个请求相关的操作ConcreteCommand: 将⼀个接受者对象与⼀个动作绑定,调⽤接受者相应的操作,实现 execute3 命令模式解决智能⽣活项⽬应⽤实例要求编写程序,使⽤命令模式完成前⾯的智能家电项⽬思路分析和图解:代码实现1 2 3 4 5 6 7 8 9 10 11//创建命令接⼝public interface Command { //执⾏动作(操作)public void execute();//撤销动作(操作)public void undo();}12 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 30public class LightOffCommand implements Command { // 聚合 LightReceiverLightReceive light;// 构造器public LightOffCommand(LightReceiver light) {super();this.light = light;}@Overridepublic void execute() {//调⽤接收者的⽅法light.off();}@Overridepublic void undo() {// 调⽤接收者的⽅法light.on();}}12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18public class LightOnCommand implements Command { //聚合 LightReceiverLightReceiver light;//构造器public LightOnCommand(LightReceiver light) {super();this.light = light;}@Overridepublic void execute() {// 调⽤接收者的⽅法light.on();1920 21 22 23 24 25 26 27 28 29 30 }@Overridepublic void undo() { //调⽤接收者的⽅法 light.off();}}1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23/**没有任何命令,即空执⾏: ⽤于初始化每个按钮, 当调⽤空命令时,对象什么都不做其实,这样是⼀种设计模式, 可以省掉对空判断@author Administrator*/public class NoCommand implements Command {@Overridepublic void execute() {}@Overridepublic void undo() {}}1 2 3 4 5 6 7 8 9 10 11 12 13 14 15public class LightReceiver {public void on() {System.out.println(" 电灯打开了.. "); }public void off() {System.out.println(" 电灯关闭了.. "); }}1 23 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 39public class RemoteController {// 开按钮的命令数组Command[] onCommands;Command[] offCommands;// 执⾏撤销的命令Command undoCommand;// 构造器,完成对按钮初始化public RemoteController() {onCommands = new Command[5];offCommands = new Command[5];for(int i = 0; i < 5; i++) {onCommands[i] = new NoCommand();offCommands[i] = new NoCommand();}}// 给我们的按钮设置你需要的命令public void setCommand(int no, Command onCommand, Command offCommand) { onCommands[no] = onCommand;offCommands[no] = offCommand;}// 按下开按钮public void onButtonWasPushed(int no) {// no 0 找到你按下的开的按钮,并调⽤对应⽅法onCommands[no].execute();// 记录这次的操作,⽤于撤销undoCommand = onCommands[no];}// 按下开按钮public void offButtonWasPushed(int no) {40 41 42 43 44 45 46 47 48 49 50 51 52 // no 0找到你按下的关的按钮,并调⽤对应⽅法 offCommands[no].execute();// 记录这次的操作,⽤于撤销undoCommand = offCommands[no];}// 按下撤销按钮public void undoButtonWasPushed() {undoCommand.undo();}}1 23 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 48public class Client {public static void main(String[] args) {//使⽤命令设计模式,完成通过遥控器,对电灯的操作//创建电灯的对象(接受者)LightReceiver lightReceiver = new LightReceiver();//创建电灯相关的开关命令LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver); LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver); //需要⼀个遥控器RemoteController remoteController = new RemoteController();//给我们的遥控器设置命令, ⽐如 no = 0 是电灯的开和关的操作remoteController.setCommand(0, lightOnCommand, lightOffCommand);System.out.println("-------- 按下灯的开按钮 -----------");remoteController.onButtonWasPushed(0);System.out.println("-------- 按下灯的关按钮 -----------");remoteController.offButtonWasPushed(0);System.out.println("-------- 按下撤销按钮----------- ");remoteController.undoButtonWasPushed();System.out.println("=========使⽤遥控器操作电视机==========");TVReceiver tvReceiver = new TVReceiver();TVOffCommand tvOffCommand = new TVOffCommand(tvReceiver);TVOnCommand tvOnCommand = new TVOnCommand(tvReceiver);//给我们的遥控器设置命令, ⽐如 no = 1 是电视机的开和关的操作remoteController.setCommand(1, tvOnCommand, tvOffCommand);System.out.println("-------- 按下电视机的开按钮 -----------");remoteController.onButtonWasPushed(1);System.out.println("-------- 按下电视机的关按钮 -----------");remoteController.offButtonWasPushed(1);System.out.println("-------- 按下撤销按钮----------- ");remoteController.undoButtonWasPushed();}}。

python设计模式-命令模式

python设计模式-命令模式

python设计模式-命令模式命令模式就是对命令的封装。

所谓封装命令,就是将⼀系列操作封装到命令类中,并且命令类只需要对外公开⼀个执⾏⽅法execute,调⽤此命令的对象只需要执⾏命令的execute⽅法就可以完成所有的操作。

这样调⽤此命令的对象就和命令具体操作之间解耦了。

更进⼀步,通过命令模式我们可以抽象出调⽤者,接收者和命令三个对象。

调⽤者就是简单的调⽤命令,然后将命令发送给接收者,⽽接收者则接收并执⾏命令,执⾏命令的⽅式也是简单的调⽤命令的execute⽅法就可以了。

发送者与接收者之间没有直接引⽤关系,发送请求的对象只需要知道如何发送请求,⽽不必知道如何完成请求。

下⾯让我们使⽤ Python 来实现命令模式。

# -*- coding: utf-8 -*-import abcclass VmReceiver(object):"""命令接收者,真正执⾏命令的地⽅"""def start(self):print("虚拟机开始")def stop(self):print("虚拟机停⽌")class Command(object):"""命令抽象类"""__metaclass__ = abc.ABCMeta@abc.abstractmethoddef execute(self):"""命令对象对外只提供 execute ⽅法"""passclass StartVmCommand(Command):"""开启虚拟机的命令"""def __init__(self, recevier):"""使⽤⼀个命令接收者初始化"""self.recevier = recevierdef execute(self):"""真正执⾏命令的时候命令接收者开启虚拟机"""self.recevier.start()class StopVmCommand(Command):"""停⽌虚拟机的命令"""def __init__(self, recevier):"""使⽤⼀个命令接收者初始化"""self.recevier = recevierdef execute(self):"""真正执⾏命令的时候命令接收者关闭虚拟机"""self.recevier.stop()class ClientInvoker(object):"""命令调⽤者"""def __init__(self, command):mand = commanddef do(self):mand.execute()if __name__ == '__main__':recevier = VmReceiver()start_command = StartVmCommand(recevier)# 命令调⽤者同时也是客户端,通过命令实例也执⾏真正的操作client = ClientInvoker(start_command)client.do()# 能告诉命令接收者执⾏不同的操作stop_command = StopVmCommand(recevier)mand = stop_commandclient.do()运⾏:E:\实验楼学习\venv\Scripts\python.exe E:/实验楼学习/设计模式/command/command-1.py虚拟机开始虚拟机停⽌Process finished with exit code 0以上代码中,通过启动和停⽌ Linux 虚拟机的例⼦实现了命令模式。

设计模式-命令行模式

设计模式-命令行模式

设计模式-命令⾏模式命令⾏模式定义:将⼀个请求封装为⼀个对象,使发出的请求的对象和执⾏请求的对象分割开。

这两者之间通过命令对象进⾏沟通,这样⽅便将命令对象进⾏储存、传递、调⽤、增加与管理。

顺序:请求者->命令->执⾏者优点:降低系统耦合度扩展性好,增加或删除命令不会影响其他类⽅便实现Undo和Redo操作,命令模式可以与备忘录模式组合使⽤可以在现有命令的基础上,增加额外功能。

命令模式结构:抽象命令类(Command):声明执⾏命令的接⼝,拥有执⾏命令的抽象⽅法 execute()具体命令类(ConcreteCommand):是抽象命令类的具体实现类,它拥有接收者对象,并通过调⽤接收者的功能来完成命令要执⾏的操作。

接收者(Receiver): 执⾏命令功能的相关操作,是命令对象业务的真正实现者请求者(Invoker):请求发送者,它拥有很多命令对象,通过访问命令对象来执⾏相关请求。

使⽤场景:在某些场合,⽐如要对⾏为进⾏“记录、撤销、重做”等处理。

或者认为是命令的地⽅。

⽰例场景:顾客点了⼀道菜,点菜这个可以当成是⼀个命令,顾客是请求者,厨师是接收者。

⽰例代码:public interface Command {void execute();}public class FoodCommand implements Command {private Receiver receiver;private String foodName;public FoodCommand(String foodName) {this.foodName = foodName;}public Receiver getReceiver() {return receiver;}public void setReceiver(Receiver receiver) {this.receiver = receiver;}@Overridepublic void execute() {receiver.action(foodName);}}/*** 顾客类*/public class Customer {private Command command;public Customer(Command command) {mand = command;}public void call(){System.out.println("顾客点菜");command.execute();}}/*** 厨师类*/public class Receiver {public void action(String foodName){System.out.println("厨师开始制作:"+foodName);}}测试代码:public class ParteenDemo {public static void main(String[] args) throws InterruptedException, CloneNotSupportedException { FoodCommand command=new FoodCommand("红烧茄⼦");Receiver receiver=new Receiver();command.setReceiver(receiver);Customer customer=new Customer(command);customer.call();}}命令模式还有⼀种扩展,与组合模式结合,称为组合命令模式。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验报告
实验题目实验三:命令模式上机实验
一、实验目的
练习并掌握命令模式,理解它的适用场景,掌握如何在实际开发过程中使用这个模式,并学会分析这个模式的使用效果。

二、完成类图的设计
三、类的实现及测试代码
interface Command {
public void execute();
public void undo();
}
class Button{
private Command command;
public void executeCommand(){
mand.execute();
}
public void undoCommand(){
mand.undo();
}
}
class Star implements Command { private Mp3 mp3;
public void execute() {
mp3.action();
}
public void undo() {
}
}
class add implements Command {
public Next(Mp3 m){
this.mp3 = m;
}
public void execute() {
mp3.action();
}
public void undo() {
}
}
class end implements Command {
public Last(Mp3 m){
this.mp3 = m;
}
public void execute() {
mp3.action();
}
public void undo() {
}
}
class Add implements Command {
private Mp3 mp3 ;
public void execute() {
mp3.action();
}
public void undo() {
}
}
class Minus implements Command { private Mp3 mp3 ;
public Minus(Mp3 m){
this.mp3 = m;
}
public void execute() {
mp3.action();
}
public void undo() {
}
}
class Menuground implements Command { private Mp3 mp3 ;
public Menuground(Mp3 m){
this.mp3 = m;
}
public void execute() {
mp3.action();
}
public void undo() {
}
}
class Mp3 {
private String name;
public Mp3 (String name){
= name;
}
public void action(){
}
}
4)、测试代码
public class Client {
public static void main(String[] args) {
Command c1 = new Star (new Mp3("stat"));
Command c2 = new Next(new Mp3("next"));
Command c3 = new Last(new Mp3("end"));
Mp3Button btn= new Mp3Button();
btn.setCommand(c1);
btn.executeCommand();
System.out.println ();
btn.setCommand(c2);
btn.undoCommand();
System.out.println ();
btn.setCommand(c3);
btn.undoCommand();
System.out.println ();
}
}
四、心得体会
通过这次实验,加深了我对命令模式的了解。

命令模式是将“请求”封装成对象,以便使用不同的请求、队列或者日志来参数化其他对象。

同时命令模式也支持可撤销的操作,还能实现队列请求,日志请求。

相关文档
最新文档