Header First设计模式学习笔记——命令模式

最新推荐文章于 2020-11-27 18:15:25 发布

weixin_34405354

最新推荐文章于 2020-11-27 18:15:25 发布

阅读量97

点赞数

文章标签：设计模式 python java

原文链接：https://my.oschina.net/v5871314/blog/283250

版权

2019独角兽企业重金招聘Python工程师标准>>>

问题引入

近来，智能家居闹得比较凶，这里我们想要实现一个简单的自动家居，由一个遥控器来完成电灯、音响、风扇的开关。

模式定义

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

认识模式

对于这个模式我最欣赏的就是他将“做什么”与"怎么做"的问题或者说是“动作的请求者”与"动作的实现者”进行了完美的解耦。并且，它支持undo的操作。

问题解决

命令模式实现步骤：

* 1、定义一个Command接口，这个接口中只含有execute()方法；

* 2、定义各个命令对象（需要实现上述的Command接口），它包含具体实现功能的对象引用，并在execute()方法中定义相应的操作；

* 3、将这个命令对象交给”动作请求者“。

直接上代码：

一、不带undo的遥控器

1>这是Command接口

package my.oschina.net.design.commands;

public interface Com {
	public void execute();
	//这个undo()撤销方法我们一会儿再说
	public void undo();
}

2>我们来定义一个开（关）灯的命令

先看看这个灯的类吧

package my.oschina.net.design.commands;

/**
 * 他包括灯的一切操作（关灯、开灯）
 * @author Eswin
 *
 */
public class Light
{
	public Light(){}
	
	public void lightOn()
	{
		System.out.println("The light is on !");
	}
			
	public void lightOff()
	{
		System.out.println("The light is off !");
	}
}

这是开关灯的命令对象

package my.oschina.net.design.commands;

public class LightOnCommand implements Com{

	private Light light;
	
	public LightOnCommand(Light light)
	{
		this.light = light;
	}
	
	public void execute()
	{
		light.lightOn();
	}

	@Override
	//显然开灯的撤销就是要关灯
	public void undo() {
		// TODO Auto-generated method stub
		light.lightOff();
	}		
}

package my.oschina.net.design.commands;

public class LightOffCommand implements Com{

	private Light light;
	
	public LightOffCommand(Light light)
	{
		this.light = light;
	}
	
	public void execute()
	{
		light.lightOff();
	}

	@Override
	//显然开灯的撤销就是要开灯
	public void undo() {
		// TODO Auto-generated method stub
		light.lightOn();
	}
}

同理对于fans也是一样的

3>是时候告诉”接收者“遥控器他可以实现的命令了

这是一个简单遥控器类（只有一个按钮，我们只是来测试这个命令，下面有个更全面的例子）

package my.oschina.net.design.commands;

public class ControlBar {
	//命令对象的引用
	Com com;
	
	public ControlBar(){}
	
	/*
	 * 通过传入Com参数决定遥控器可以实现的命令
	 */
	public void setCommand(Com com)
	{
		this.com = com;
	}
	
	//一旦我们按下按钮(下命令)，就有真正的接受者完成相应的任务，我们的遥控器并不需要知道到底是如何实现的
	public void pressDown()
	{
		com.execute();
	}
}

Test一下吧

package my.oschina.net.design.commands;

public class TestCom {
	
	public static void main(String[] args)
	{
		Light light = new Light();	
		Com com1 = new LightOnCommand(light);
		Com com2 = new LightOffCommand(light);
		
		Fans fans = new Fans();
		Com com3 = new FansOnCommand(fans);
		Com com4 = new FansOffCommand(fans);
		
		ControlBar clb = new ControlBar();
		clb.setCommand(com1);
		clb.pressDown();
		
		clb.setCommand(com2);
		clb.pressDown();
		
		clb.setCommand(com3);
		clb.pressDown();
		
		clb.setCommand(com4);
		clb.pressDown();	
	}
}

可以看到我们设置好命令，然后只需要PressDown按钮，就可以完成相应的命令

结果如下：

二、带有undo的遥控器

这是一个很炫酷的功能。你肯定遇到过这样尴尬的情况，当你做下一个决定的那一刻你就发现自己后悔了（很奇妙），怎么办？？？没事，我们提供了undo功能！

undo说到底很简单，就是撤销上步操作(没错，就是ctrl + z)，换句话说，就是执行与你上一步的动作相反的动作（你开了我就关）

回头看看LightOnCommand和LightOffCommand命令中的undo操作！确实很简单！

好了，我们可以在遥控器上加上这个硬件按钮了。

接下来我们创建一个真实的遥控器，遥控器上有多个控制按钮，分别实现各个功能。

这是遥控器类：

package my.oschina.net.design.commands;

import java.util.Stack;

public class ControlBar2 {

        //我们将命令放在数组中更加清晰一点
	Com[] oncoms;
	Com[] offcoms;
	
	//这是个撤销命令对象的引用
	Com undoCom;
	
	//用栈来保存每次需要撤销的操作，从而可以一直undo（当然也是有一定次数限制的）
	public Stack<Com> in_undo_satck = new Stack<Com>();
	
	ControlBar2()
	{
		//记得生成这个数组，要不然出现空指针的现象
		oncoms = new Com[3];
		offcoms = new Com[3];
	}
	/**
	 * 
	 * @param i 遥控器的命令插槽，用于标识控制的是什么（电灯？电扇？）
	 * @param oncom 控制对象的开命令
	 * @param offcom 控制对象的关命令
	 */
	public void setCommand(int i, Com oncom, Com offcom)
	{	
		oncoms[i] = oncom;
		offcoms[i] = offcom;		
	}
	
	//开按钮
	public void pressOn(int i)
	{
		oncoms[i].execute();
		记录下上一次执行的动作，
		undoCom = oncoms[i];
		
		//将上一次将执行的动作记录到栈中，一会弹出一次调用undo()方法
		in_undo_satck.push(undoCom);
		
	}
	
	//关按钮
	public void pressOff(int i)
	{
		offcoms[i].execute();
		undoCom = offcoms[i];
		
		//将上一次将执行的动作记录到栈中，一会弹出一次调用undo()方法
		in_undo_satck.push(undoCom);
		
	}	
	
	/*带参数的undo撤销按钮，根据传入的i（标识控制哪个对象），对相应的开操作做撤销,这个可以不要
	public void Pressundo(int i)
	{
		oncoms[i].undo();	
		in_undo_satck.push(undoCom);
	}
	*/
	
	//undo撤销按钮（终于见到你了）
	public void Pressundo()
	{
	        //将上一次将执行的动作记录到栈中，一会弹出一次调用undo()方法，撤销的命令也可以压入栈中，进行撤销操作
		if(!in_undo_satck.isEmpty())		
			in_undo_satck.pop().undo();
	}
}

好了，Test一下

package my.oschina.net.design.commands;

public class TestControlBar2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建一个Light对象
		Light light = new Light();
		//用Light对象初始化LightOnComman与LightOffCommand命令对象
		Com com1 = new LightOnCommand(light);
		Com com2 = new LightOffCommand(light);
		
		//创建一个Fans对象
		Fans fans = new Fans();
		//用Light对象初始化FansOnComman与FansOffCommand命令对象
		Com com3 = new FansOnCommand(fans);
		Com com4 = new FansOffCommand(fans);
		
		//这是一个遥控器
		ControlBar2 clb = new ControlBar2();	
		//在各个插槽上绑定命令	
		clb.setCommand(0, com1, com2);
		clb.setCommand(1, com3, com4);
		
		//记住了我们绑定的命令0上绑定的是对Light的操作
		clb.pressOn(0);	
		clb.pressOff(0);
		
		clb.pressOn(1);	
		clb.pressOff(1);
		clb.pressOn(1);	
		clb.pressOn(0);	
		
		clb.pressOn(1);	
		clb.pressOff(1);

		System.out.println("UNDO ------------> ");
		while( clb.in_undo_satck.iterator().hasNext())
			clb.Pressundo();
			
	}
		
}

预测结果：

从分割线（UNDO --------------->）处，两边是成镜像对称的。

实际结果（丝毫不差）：