设计模式－command模式

定义命令模式

　　命令模式将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。命令对象将动作和接收者包进对象中。

应用场景

　　在面向对象的软件设计中，经常会遇到一个（或一系列）对象，对象本身的数据存储与对象的操作耦合在一起。例如一个对象有add(),edit(),delete()方法，这样对象支持的方法很难扩展，如果需要加入update()就必须修改代码，客户端与对象也是紧耦合的。命令模式是将一类对象的功能（行为，功能）抽象成一个命令对象，客户端在使用的时候，只与该命令对象打交道，而不用与对象打交道，分离命令的请求者和命令的执行者，降低了耦合性，可以使用不同的请求对客户进行参数化提高了程序设计的灵活性。

命令模式的类图

　　　 　下面是Head First设计模式上面定义命令模式的类图 　遥控器问题:有一个附着多组开关按钮的遥控器，带有可编程插槽，每个都可以指定到一个不同的家电装置；有很多厂商开发的各种家电装置控制类；希望创建一组API，让每个插槽控制一个或一组装置。下面是Head First设计模式上实现遥控器问题的类图

　遥控器问题：

可以把遥控器的按钮看做是一个命令，按下命令的时候不需要知道命令是怎么执行的，我们可以将遥控器每个按键看做是一个命令对象，实现的时候用数组来表示遥控器的按钮位置，然后为数组赋值具体对应的命令对象

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");
	}
}
//命令类实现
class LivingroomLightOffCommand implements Command {
	Light light;

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

	public void execute() {
		light.off();
	}
}
 class LivingroomLightOnCommand implements Command {
	Light light;

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

	public void execute() {
		light.on();
	}
}
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);
    }
}
 class StereoOffCommand implements Command {
    Stereo stereo;
 
    public StereoOffCommand(Stereo stereo) {
        this.stereo = stereo;
    }
 
    public void execute() {
        stereo.off();
    }
}
 class StereoOnWithCDCommand implements Command {
    Stereo stereo;
 
    public StereoOnWithCDCommand(Stereo stereo) {
        this.stereo = stereo;
    }
 
    public void execute() {
        stereo.on();
        stereo.setCD();
        stereo.setVolume(11);
    }
}

 class NoCommand implements Command {
    public void execute() { }
    public void undo() { }
}
 // This is the invoker
//
//invoker相当于订单。它可以调用execute方法
 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; //在构造器中将每个插槽都预先指定成noCommand对象，以便确定每个插槽永远都有命令对象
		}
	}
  //将命令记录在开关数组中对应的插槽位置插槽
	public void setCommand(int slot, Command onCommand, Command offCommand) {
		onCommands[slot] = onCommand;
		offCommands[slot] = offCommand;
	}
  //按下按键 调用execute
	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();
	}
}
//测试
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);

		StereoOnWithCDCommand stereoOnWithCD =
				new StereoOnWithCDCommand(stereo);
		StereoOffCommand  stereoOff =
				new StereoOffCommand(stereo);
 
		remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
		remoteControl.setCommand(１, stereoOnWithCD, stereoOff);
  
		System.out.println(remoteControl)
 
		remoteControl.onButtonWasPushed(0);
		remoteControl.offButtonWasPushed(0);
		remoteControl.onButtonWasPushed(1);
		remoteControl.offButtonWasPushed(1);

	}
}

撤销操作的实现

　新加入undo方法　然后每个具体的命令类都实现这个方法：undo方法中调用的操作和execute()方法中的操作相反，比如on的反面是off。

　遥控器类也要做一些修改：加入新的实例变量记录上一个操作，当按下撤销按钮，就调用该实例变量的undo()方法。

　如果撤销到某一个状态需要记录一些变量值，则在execute()方法中加入保存操作前状态数值的语句，然后在undo()的时候恢复。

例如将一个控制电风扇的命令加上undo方法

public class CeilingFanOffCommand implements Command {
	CeilingFan ceilingFan;
	int prevSpeed;
  
	public CeilingFanOffCommand(CeilingFan ceilingFan) {
		this.ceilingFan = ceilingFan;
	}
 
	public void execute() {
		prevSpeed = ceilingFan.getSpeed();
		ceilingFan.off();
	}
 
	public void undo() {
		if (prevSpeed == CeilingFan.HIGH) {
			ceilingFan.high();
		} else if (prevSpeed == CeilingFan.MEDIUM) {
			ceilingFan.medium();
		} else if (prevSpeed == CeilingFan.LOW) {
			ceilingFan.low();
		} else if (prevSpeed == CeilingFan.OFF) {
			ceilingFan.off();
		}
	}
}

实现Party模式

  　实现Party模式就是按下一个遥控器开关按钮会有一系列的执行者j接收到命令按一定的次序执行操作。实现得方法是使用宏命令，用命令数组存储一大堆命令，在execute()方法中用一个for循环遍历这个数组，依次执行数组各个执行对象的execute

    

//实现命令数组
class MacroCommand implements Command {
	Command[] commands;
 
	public MacroCommand(Command[] commands) {
		this.commands = commands;
	}
 
	public void execute() {
		for (int i = 0; i < commands.length; i++) {
			commands[i].execute();
		}
	}
 
	public void undo() {
		for (int i = 0; i < commands.length; i++) {
			commands[i].undo();
		}
	}
}
//使用宏命令示例
　　　　Command[] partyOn = { lightOn, stereoOn, tvOn, hottubOn};
		Command[] partyOff = { lightOff, stereoOff, tvOff, hottubOff};
  
		MacroCommand partyOnMacro = new MacroCommand(partyOn);
		MacroCommand partyOffMacro = new MacroCommand(partyOff);
 
		remoteControl.setCommand(0, partyOnMacro, partyOffMacro);
  
		System.out.println(remoteControl);
		System.out.println("--- Pushing Macro On---");
		remoteControl.onButtonWasPushed(0);
		System.out.println("--- Pushing Macro Off---");
		remoteControl.offButtonWasPushed(0);