命令模式

最新推荐文章于 2024-10-17 09:45:23 发布
最新推荐文章于 2024-10-17 09:45:23 发布
阅读量484 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/finnfu/article/details/46494069
版权

一.很吊的前言

这些绝密的文件投递箱已经促成了间谍工业的革命。我只需要把需求丢进去，就会有人消失，政府一夜之间改朝换代，而我的干洗衣服也洗好了。我不必管它们是何时，何地，如何完成的，反正就是完成了。

二.简单的命令模式实例

现在智能硬件这么火，我想设计一个可以遥控床头灯的遥控器，可以实现灯的开或者关在这个设计里面，涉及到哪些类呢，有床头灯，有遥控器，遥控器怎么打开灯呢，我首先的想法如下：
1.在遥控器中有一个Light的成员变量light
2.new出遥控器实例的时候就对light赋一个Light的实例
3.在遥控器的open和close中调用light的open和close

以上的设计有什么缺点：
遥控器无法扩展了，如果我想控制空调怎么办，想设计一个牛逼的遥控器，这种设计显然是失败的。

那怎么办，这样改进呢：
在代码中添加一个空调的引用，这样就可以将遥控器设置为空调的遥控器了，可是下次我要控制风扇怎么办，难道一只要更改遥控器的代码么，显然不行。

终极的办法来了，命令模式初显身手：
将各种命令也设计为一个类，开灯，关灯，开空调，关空调都是我们可以扩展的类，而遥控器的按钮我们可以setCommond，将各种命令类的实例赋给遥控器中的Commond超类实例。

看代码，很简单的，首先是命令的接口：
 
public interface Command {
	public void execute();
}
灯： 
public class Light {

	public Light() {
	}

	public void on() {
		System.out.println("Light is on");
	}

	public void off() {
		System.out.println("Light is off");
	}
}
开灯关灯的命令类： 
public class LightOnCommand implements Command {
	Light light;
  
	public LightOnCommand(Light light) {
		this.light = light;
	}
 
	public void execute() {
		light.on();
	}
}

public class LightOffCommand implements Command {
	Light light;
 
	public LightOffCommand(Light light) {
		this.light = light;
	}
 
	public void execute() {
		light.off();
	}
}

遥控器类，用setCommond，实现了扩展： 
public class SimpleRemoteControl {
	Command slot;
 
	public SimpleRemoteControl() {}
 
	public void setCommand(Command command) {
		slot = command;
	}
 
	public void buttonWasPressed() {
		slot.execute();
	}
}

下面是测试函数： 
public class RemoteControlTest {
	public static void main(String[] args) {
		SimpleRemoteControl remote = new SimpleRemoteControl();
		Light light = new Light();
		LightOnCommand lightOn = new LightOnCommand(light);
		remote.setCommand(lightOn);
		remote.buttonWasPressed();	
    }
}

三.完整的家用多功能遥控器

上面的例子其实只是针对遥控器的某一个按钮实现了功能，可以开或者关，下面来实现一个完成的家用多功能遥控器，可以控制风扇，门，灯，热浴盆，CD唱片机。

家用电器类以及对应的命令类:
 
//灯
public class Light {
	String location = "";

	public Light(String location) {
		this.location = location;
	}

	public void on() {
		System.out.println(location + " light is on");
	}

	public void off() {
		System.out.println(location + " light is off");
	}
}

//灯对应的命令
public class LightOffCommand implements Command {
	Light light;
 
	public LightOffCommand(Light light) {
		this.light = light;
	}
 
	public void execute() {
		light.off();
	}
}

public class LightOnCommand implements Command {
	Light light;

	public LightOnCommand(Light light) {
		this.light = light;
	}

	public void execute() {
		light.on();
	}
}

public class LivingroomLightOffCommand implements Command {
	Light light;

	public LivingroomLightOffCommand(Light light) {
		this.light = light;
	}

	public void execute() {
		light.off();
	}
}

public class LivingroomLightOnCommand implements Command {
	Light light;

	public LivingroomLightOnCommand(Light light) {
		this.light = light;
	}

	public void execute() {
		light.on();
	}
}




//CD唱片机
public class Stereo {
	String location;

	public Stereo(String location) {
		this.location = location;
	}

	public void on() {
		System.out.println(location + " stereo is on");
	}

	public void off() {
		System.out.println(location + " stereo is off");
	}

	public void setCD() {
		System.out.println(location + " stereo is set for CD input");
	}

	public void setDVD() {
		System.out.println(location + " stereo is set for DVD input");
	}

	public void setRadio() {
		System.out.println(location + " stereo is set for Radio");
	}

	public void setVolume(int volume) {
		// code to set the volume
		// valid range: 1-11 (after all 11 is better than 10, right?)
		System.out.println(location + " Stereo volume set to " + volume);
	}
}

//CD唱片机对应命令
public class StereoOnWithCDCommand implements Command {
	Stereo stereo;
 
	public StereoOnWithCDCommand(Stereo stereo) {
		this.stereo = stereo;
	}
 
	public void execute() {
		stereo.on();
		stereo.setCD();
		stereo.setVolume(11);
	}
}

public class StereoOffCommand implements Command {
	Stereo stereo;
 
	public StereoOffCommand(Stereo stereo) {
		this.stereo = stereo;
	}
 
	public void execute() {
		stereo.off();
	}
}


//风扇
public class CeilingFan {
	String location = "";
	int level;
	public static final int HIGH = 2;
	public static final int MEDIUM = 1;
	public static final int LOW = 0;
 
	public CeilingFan(String location) {
		this.location = location;
	}
  
	public void high() {
		// turns the ceiling fan on to high
		level = HIGH;
		System.out.println(location + " ceiling fan is on high");
 
	} 

	public void medium() {
		// turns the ceiling fan on to medium
		level = MEDIUM;
		System.out.println(location + " ceiling fan is on medium");
	}

	public void low() {
		// turns the ceiling fan on to low
		level = LOW;
		System.out.println(location + " ceiling fan is on low");
	}
 
	public void off() {
		// turns the ceiling fan off
		level = 0;
		System.out.println(location + " ceiling fan is off");
	}
 
	public int getSpeed() {
		return level;
	}
}

//风扇的命令
public class CeilingFanOffCommand implements Command {
	CeilingFan ceilingFan;

	public CeilingFanOffCommand(CeilingFan ceilingFan) {
		this.ceilingFan = ceilingFan;
	}
	public void execute() {
		ceilingFan.off();
	}
}

public class CeilingFanOnCommand implements Command {
	CeilingFan ceilingFan;

	public CeilingFanOnCommand(CeilingFan ceilingFan) {
		this.ceilingFan = ceilingFan;
	}
	public void execute() {
		ceilingFan.high();
	}
}



//门
public class GarageDoor {
	String location;

	public GarageDoor(String location) {
		this.location = location;
	}

	public void up() {
		System.out.println(location + " garage Door is Up");
	}

	public void down() {
		System.out.println(location + " garage Door is Down");
	}

	public void stop() {
		System.out.println(location + " garage Door is Stopped");
	}

	public void lightOn() {
		System.out.println(location + " garage light is on");
	}

	public void lightOff() {
		System.out.println(location + " garage light is off");
	}
}

//门的命令
public class GarageDoorDownCommand implements Command {
	GarageDoor garageDoor;

	public GarageDoorDownCommand(GarageDoor garageDoor) {
		this.garageDoor = garageDoor;
	}

	public void execute() {
		garageDoor.up();
	}
}

public class GarageDoorUpCommand implements Command {
	GarageDoor garageDoor;

	public GarageDoorUpCommand(GarageDoor garageDoor) {
		this.garageDoor = garageDoor;
	}

	public void execute() {
		garageDoor.up();
	}
}


//热浴盆
public class Hottub {
	boolean on;
	int temperature;

	public Hottub() {
	}

	public void on() {
		on = true;
	}

	public void off() {
		on = false;
	}

	public void bubblesOn() {
		if (on) {
			System.out.println("Hottub is bubbling!");
		}
	}

	public void bubblesOff() {
		if (on) {
			System.out.println("Hottub is not bubbling");
		}
	}

	public void jetsOn() {
		if (on) {
			System.out.println("Hottub jets are on");
		}
	}

	public void jetsOff() {
		if (on) {
			System.out.println("Hottub jets are off");
		}
	}

	public void setTemperature(int temperature) {
		this.temperature = temperature;
	}

	public void heat() {
		temperature = 105;
		System.out.println("Hottub is heating to a steaming 105 degrees");
	}

	public void cool() {
		temperature = 98;
		System.out.println("Hottub is cooling to 98 degrees");
	}

}

//热浴盆的命令
public class HottubOffCommand implements Command {
	Hottub hottub;

	public HottubOffCommand(Hottub hottub) {
		this.hottub = hottub;
	}

	public void execute() {
		hottub.cool();
		hottub.off();
	}
}

public class HottubOnCommand implements Command {
	Hottub hottub;

	public HottubOnCommand(Hottub hottub) {
		this.hottub = hottub;
	}

	public void execute() {
		hottub.on();
		hottub.heat();
		hottub.bubblesOn();
	}
}

遥控器，一共有14个按钮，7个开，7个关： 
public class RemoteControl {
	Command[] onCommands;
	Command[] offCommands;
 
	public RemoteControl() {
		onCommands = new Command[7];
		offCommands = new Command[7];
 
		Command noCommand = new NoCommand();
		for (int i = 0; i < 7; i++) {
			onCommands[i] = noCommand;
			offCommands[i] = noCommand;
		}
	}
	//可以设置某一对按钮的命令
	public void setCommand(int slot, Command onCommand, Command offCommand) {
		onCommands[slot] = onCommand;
		offCommands[slot] = offCommand;
	}
 
	public void onButtonWasPushed(int slot) {
		onCommands[slot].execute();
	}
 
	public void offButtonWasPushed(int slot) {
		offCommands[slot].execute();
	}
  
	public String toString() {
		StringBuffer stringBuff = new StringBuffer();
		stringBuff.append("\n------ Remote Control -------\n");
		for (int i = 0; i < onCommands.length; i++) {
			stringBuff.append("[slot " + i + "] " + onCommands[i].getClass().getName()
				+ "    " + offCommands[i].getClass().getName() + "\n");
		}
		return stringBuff.toString();
	}
}

上面每个按钮的初始化时，都初始化为NoCommand，它什么都不做： 
public class NoCommand implements Command {
	public void execute() { }
}

下面是测试函数： 
public class RemoteLoader {
 
	public static void main(String[] args) {
		RemoteControl remoteControl = new RemoteControl();
 
		Light livingRoomLight = new Light("Living Room");
		Light kitchenLight = new Light("Kitchen");
		CeilingFan ceilingFan= new CeilingFan("Living Room");
		GarageDoor garageDoor = new GarageDoor("");
		Stereo stereo = new Stereo("Living Room");
  
		LightOnCommand livingRoomLightOn = 
				new LightOnCommand(livingRoomLight);
		LightOffCommand livingRoomLightOff = 
				new LightOffCommand(livingRoomLight);
		LightOnCommand kitchenLightOn = 
				new LightOnCommand(kitchenLight);
		LightOffCommand kitchenLightOff = 
				new LightOffCommand(kitchenLight);
  
		CeilingFanOnCommand ceilingFanOn = 
				new CeilingFanOnCommand(ceilingFan);
		CeilingFanOffCommand ceilingFanOff = 
				new CeilingFanOffCommand(ceilingFan);
 
		GarageDoorUpCommand garageDoorUp =
				new GarageDoorUpCommand(garageDoor);
		GarageDoorDownCommand garageDoorDown =
				new GarageDoorDownCommand(garageDoor);
 
		StereoOnWithCDCommand stereoOnWithCD =
				new StereoOnWithCDCommand(stereo);
		StereoOffCommand  stereoOff =
				new StereoOffCommand(stereo);
 
		remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
		remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
		remoteControl.setCommand(2, ceilingFanOn, ceilingFanOff);
		remoteControl.setCommand(3, stereoOnWithCD, stereoOff);
  
		System.out.println(remoteControl);
 
		remoteControl.onButtonWasPushed(0);
		remoteControl.offButtonWasPushed(0);
		remoteControl.onButtonWasPushed(1);
		remoteControl.offButtonWasPushed(1);
		remoteControl.onButtonWasPushed(2);
		remoteControl.offButtonWasPushed(2);
		remoteControl.onButtonWasPushed(3);
		remoteControl.offButtonWasPushed(3);
	}
}

如果想加入一个撤销按钮，对命令以及遥控器做如下修改： 
public class LightOnCommand implements Command {
	Light light;	
	public LightOnCommand(Light light) {
		this.light = light;
	}
 
	public void execute() {    
		light.on();
	}
 
	public void undo() {
		light.off();
	}
}

public class RemoteControlWithUndo {
	Command[] onCommands;
	Command[] offCommands;
	Command undoCommand;
 
	public RemoteControlWithUndo() {
		onCommands = new Command[7];
		offCommands = new Command[7];
 
		Command noCommand = new NoCommand();
		for(int i=0;i<7;i++) {
			onCommands[i] = noCommand;
			offCommands[i] = noCommand;
		}
		undoCommand = noCommand;
	}
  
	public void setCommand(int slot, Command onCommand, Command offCommand) {
		onCommands[slot] = onCommand;
		offCommands[slot] = offCommand;
	}
 
	public void onButtonWasPushed(int slot) {
		onCommands[slot].execute();
		undoCommand = onCommands[slot];
	}
 
	public void offButtonWasPushed(int slot) {
		offCommands[slot].execute();
		undoCommand = offCommands[slot];
	}
 
	public void undoButtonWasPushed() {
		undoCommand.undo();
	}
  
	public String toString() {
		StringBuffer stringBuff = new StringBuffer();
		stringBuff.append("\n------ Remote Control -------\n");
		for (int i = 0; i < onCommands.length; i++) {
			stringBuff.append("[slot " + i + "] " + onCommands[i].getClass().getName()
				+ "    " + offCommands[i].getClass().getName() + "\n");
		}
		stringBuff.append("[undo] " + undoCommand.getClass().getName() + "\n");
		return stringBuff.toString();
	}
}

这样就完成的遥控器了，个人觉得充分理解实例二的思想就可以了，这其实也是针对接口编程，而不是实现，并且运动了组合的思想。







finnfu
关注
专栏目录
组合-命令模式----实例分析
m0_56134903的博客
12-16 1418
应用场景 使用组合命令模式实现多功能开关,让用户进行设置,要么控制教室的所有灯的开和关，要么控制教室所有风扇的开和关，要么控制教室所有空调的开和关，要么控制教室里教学多媒体设备的开和关。 模式结构视图 代码设计 控制器类 public class Oyy22Controller { private Oyy22Command lightsOpenCommand, lightsCloseCommand, blowerOpenCommand, blowerCloseCommand, airOpenCom
Java基于命令模式实现邮局发信功能详解
08-27
Java基于命令模式实现邮局发信功能详解 命令模式是 Java 中的一种设计模式，它将来自客户端的请求封装成一个对象，无须了解这个请求激活的动作或有关接受这个请求的处理细节。命令模式的根本目的在于将"请求者"与...
设计模式之 命令模式实例笔记
whjk20的专栏
09-29 265
模拟一个电器遥控器，里面可以控制电灯/电视/空调等电器的 开 和 关 ， 并且提供 撤销按钮。 1. 命令抽象接口 interface Command { fun execute() fun undo() } 2. 接收者(最终实现者) import android.util.Log class LightReceiver { fun on() { Log.d("LightReceiver", "电灯打开了.......") } f
命令模式（行为型）
m0_45329584的博客
03-21 640
1.命令 1.1定义 命令模式：将一个请求封装为一个对象，从而让你可以用不同的请求对客户进行参数化，对请求排队或者记录请求日志，以及支持可撤销的操作。 对象行为型模式 命令模式的定义说明： 别名为动作(Action)模式或事务(Transaction)模式 “用不同的请求对客户进行参数化”-例如吃面佐料要求 “对请求排队”-例如吃饭排队 “记录请求日志”-例如点菜单 “支持可撤销操作”-例如点菜取消 1.2角色 命令模式包含以下4个角色： Command（抽象命令类） Concre
浅谈设计模式之命令模式
zhq931218的博客
06-01 218
命令模式是将发起命令者（比如万能遥控器）和接收命令者（比如电视、空调）进行解耦的一种模式。命令模式通过将命令封装成对象，让每个命令对象实现同一个接口，这样对于命令发起者，只需要持有该命令对象，并调用接口中通用的方法即可，而不需要关心命令对象实现的细节。命令模式的主要代码如下： 首先是命令的接口，它对外暴露一个方法： public interface Command{ void execute(); } 然后是命令对象，这个对象会持有一个具体的目标类，拿tv举例： public class TVTurnOnC
c++命令模式
qq_71286244的博客
08-30 4748
c++命令模式详细介绍
设计模式之【命令模式】，方法调用的花式玩法
秃了也弱了
05-17 3033
命令模式（Command Pattern）是对命令的封装，每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。命令模式解耦了请求方和接收方，请求方只需请求执行命令，不用关心命令是怎样被接受，怎样被操作以及是否被执行等。命令模式属于行为型模式。原文：将一个请求封装成医德对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。在软件系统中，行为请求者与行为实现者通常是一种紧耦合关系，因为这样的实现简单明了。
详解Java设计模式——命令模式
08-26
命令模式是Java设计模式中的一种常见模式，主要用于将命令的发出者和执行者之间解耦，实现请求和执行分开。 命令模式的定义是将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。它的主要目的是...
JavaScript设计模式经典之命令模式
11-23
命令模式是一种设计模式，它将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。在JavaScript中，命令模式的应用同样广泛，能够帮助我们更好地...
通过c++11改进我们的模式之改进命令模式
01-20
　命令模式的作用是将请求封装为一个对象，将请求的发起者和执行者解耦，支持对请求排队以及撤销和重做。它的类图如下: 　由于将请求都封装成一个个命令对象了，使得我们可以集中处理或者延迟处理这些命令请求，而且...
Linux vim编辑命令模式
01-10
vi(vim)是上Linux非常常用的编辑器，很多Linux发行版都默认安装了vi(vim)。vi(vim)命令繁多但是如果使用灵活...vi有3个模式：插入模式、命令模式、低行模式。 插入模式：在此模式下可以输入字符，按ESC将回到命令模式。
23种设计模式具体实现方法
晴山の博客
10-16 686
前期疑问：适配器模式的优点主要包括：（1）提高类的透明性和复用性： 适配器模式可以让类在现有的基础上进行复用，而不需要做出任何改变，这有助于避免大规模改写现有代码。（2）解耦目标类和适配器类： 通过使用适配器模式，目标类和适配器类可以实现解耦，从而提高程序的扩展性。这符合开闭原则，即对扩展开放，对修改关闭。（3）更好的扩展性： 在实现适配器功能的时候，可以调用自己开发的功能，从而自然地扩展系统的功能。（4）灵活性好： 适配器并没有影响原有功能，如果不想使用，可以直接删除。
设计模式，面试级别的详解(持续更新中)
qq_51321722的博客
10-16 672
其实很简单，第一重判断，如果实例已经存在，那么就不再需要进行同步操作，而是直接返回这个实例，如果没有创建，才会进入同步块，同步块的目的与之前相同，目的是为了防止有多个线程同时调用时，导致生成多个实例，有了同步块，每次只能有一个线程调用访问同步块内容，当第一个抢到锁的调用获取了实例之后，这个实例就会被创建，之后的所有调用都不会进入同步块，直接在第一重判断就返回了单例。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。，这种方式比较常用，但容易产生垃圾对象，浪费内存空间。
设计模式02-桥接模式(Java)
XYX_888的博客
10-13 720
它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。在使用关联关系是，及在抽象类引入实现类接口时可能会出现不适配的情况，这是可以用适配器类型将其转换成抽象类可以适配的类进行关联。扩展抽象化角色 ：是抽象化角色的子类，实现父类中的业务方法， 并通过组合关系调用实现化角色中的业务方法。实现化角色 ：定义实现化角色的接口，供扩展抽象化角色调用。抽象化角色 ：定义抽象类，并包含一个对实现化对象的引用。具体实现化角色 ：给出实现化角色接口的具体实现。实现了对抽象和实现之间的解耦。
Java设计模式梳理：行为型模式（策略，观察者等）
最新发布
helloworld工程师的博客
10-17 1202
行为型模式部分介绍了策略模式、观察者模式、责任链模式、模板方法模式和状态模式，其实，经典的行为型模式还包括备忘录模式、命令模式等，但是它们的使用场景比较有限，而且本文篇幅也挺大了，我就不进行介绍了。学习设计模式的目的是为了让我们的代码更加的优雅、易维护、易扩展。这次整理这篇文章，让我重新审视了一下各个设计模式，对我自己而言收获还是挺大的。我想，文章的最大收益者一般都是作者本人，为了写一篇文章，需要巩固自己的知识，需要寻找各种资料，而且，自己写过的才最容易记住，也算是我给读者的建议吧。（全文完）
开发中众多框架的个人理解,Unity设计模式，MVC,MVVM框架
m0_73727069的博客
10-14 1284
在软件开发中，架构模式是设计和组织代码的重要方法。本文将详细介绍三种流行的架构模式：ECS（Entity-Component-System）、MVC（Model-View-Controller）和MVVM（Model-View-ViewModel）。我们将探讨它们的定义、特点、优缺点以及在实际开发中的应用示例。
Java设计模式10 - 观察者模式
Java_fenxiang的博客
10-14 857
观察者模式观察者模式也叫作发布-订阅模式，也就是事件监听机制。观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己。观察者模式的结构一个软件系统常常要求在某一个对象状态发生变化时，某些其他的对象作出相应的改变。能做到这一点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值