命令模式

参考：http://blog.csdn.net/fatherican/article/details/44966891

依赖关系(Dependence)

依赖关系（Dependence）：假设A类的变化引起了B类的变化，则说名B类依赖于A类。

 在UML中，依赖关系用带箭头的虚线表示，由依赖的一方指向被依赖的一方。

 

public class Driver
{
　　public void drive(Car car)
　　{
　　　　car.move();
　　}
　　……
}
public class Car
{
　　public void move()
　　{
　　　　......
　　}
　　……
}

依赖关系有如下三种情况：

1、A类是B类中的（某中方法的）局部变量；

2、A类是B类方法当中的一个参数；

3、A类向B类发送消息，从而影响B类发生变化；

-------------------------------------------------------------------------------------------------------------------

oo原则：

封装变化

多用组合，少用继承

针对接口编程，不针对实现编程

为交互对象之间松耦合设计而努力

类应该对扩展开放，对修改关闭

依赖抽象，不要依赖具体类

------------------------------------------------------------------------------------------------------

命令模式：

发出请求的对象 和 执行请求的对象 解耦。

两者之间通过命令对象进行沟通。

命令可以撤销，方法是：实现接口的undo()方法

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

命令模式的用途：队列请求，实现日志和事物系统。

伪代码：

//执行者
public class Light{

    public void on()
    {
        //打开...
    }
    
    public void off()
    {
        //关闭....
    }
}

//接口
public interface Command
{
    public void execute();
    public void undo();
}

//命令对象
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 void onButtonWasPushed(int slot)
{
    if(OnCommands[slot] != null)
    {
        OnCommands[slot].execute();
    }
}
//实现一个不做任何事情的命令。避免每次判断是否加载了命名
public class NoCommand implements Command
{
    public void execute()
    {    
    }
    
    public void undo()
    {    
    }
}
NoCommand对象是一个空对象（null object）的例子。当你不想返回一个有意义的对象时，空对象
就很有用。在许多设计模式中，都会看到空对象的使用。甚至有些时候，空对象本身也被视为是一种
设计模式。




//批量命令执行
public 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();
        }
    }
    
}

//调用者
public class RemoteCtrl{
    Command[] OnCommands;
    Command[] OffCommands;
    Command undoCommand;//撤销
    
    public RemoteCtrl()
    {
        OnCommands = new Command[7];
        OffCommands = new Command[7];
        
        Command noCommand = new Command();
        for(int i=0;i<7;i++)
        {
            OffCommands[i] = noCommand;
            OnCommands[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(int slot)
    {
        undoCommand.undo();
    }
    
    
}

--------------------------------------------------------------------



//初始化设置
public class RemoteLoader
{

    public static void main(String[] args)
    {
        //调用者
        RemoteCtrl remoteCtrl = new RemoteCtrl();
        
    
        //执行者
        Light light     = new Light("Bedroom");
        Tv    tv        = new Tv("Living room");
        Stereo stereo     = new Stereo("Living room");
        HotTub hutTub   = new HotTub("Hot tub");

        //命令对象
        OnCommandLigth lightOn = new OnCommandLigth(light);
        OnCommandTv       tvOn = new OnCommandTv(tv);
        OnCommandStereo stereoOn = new OnCommandStereo(stereo);
        OnCommandHotTub    hotTubOn = new OnCommandHotTub(hutTub);

        //命令对象
        OffCommandLigth    lightOff  = new OffCommandLigth(light);
        OffCommandTv       tvOff     = new OffCommandTv(tv);
        OffCommandStereo   stereoOff = new OffCommandStereo(stereo);
        OffCommandHotTub   hotTubOff = new OffCommandHotTub(hutTub);

        //批量命令
        Command[] partyOn = {lightOn, tvOn, stereoOn, hotTubOn};
        Command[] partyOff = {lightOff, tvOff, stereoOff, hotTubOff};
        
        //命令对象
        MacroCommand onMacroCommand = new MacroCommand(partyOn);
        MacroCommand offMacroCommand = new MacroCommand(partyOff);
        
        
        remoteCtrl.setCommand(0, onMacroCommand, offMacroCommand);
        
        remoteCtrl.setCommand(1, lightOn, lightOff);
        
        remoteCtrl.setCommand(2, tvOn, tvOff);
        
        remoteCtrl.setCommand(3, stereoOn, stereoOff);
        
        remoteCtrl.setCommand(4, hotTubOff, hotTubOff);
        
        
        //测试
        remoteCtrl.onButtonWasPushed(1);//打开电灯
        remoteCtrl.offButtonWasPushed(1);//关闭电灯
        remoteCtrl.undoButtonWasPushed(1);//撤销操作，执行打开电灯
        
        remoteCtrl.onButtonWasPushed(2);//打开电视
        remoteCtrl.offButtonWasPushed(2);//关闭电视
        

        
    }

}



//使用状态实现撤销
通常实现撤销的功能，需要记录一些状态。比方说吊扇，吊扇允许有多种转速，当然也允许被关闭。
public class CeilingFan{
    public static final int HIGH = 3;
    public static final int MEDIUM = 2;
    public static final int LOW = 1;
    public static final int OFF = 0;
    String location;
    int speed;
    
    public CeilingFan(String location)
    {
        this.location = location;
        speed = OFF;
    }
    
    public void high()
    {
        speed = HIGH;
        
        //设置高转速
    }
    
    public void medium()
    {
        speed = MEDIUM;
        
        //...
    }
    
    public void low()
    {
        speed = LOW;
        
        //...
    }
    
    public void off()
    {
        speed = OFF;
        
        //...
    }
    
    //风扇当前的档位
    public int getSpeed()
    {
        return speed;
    }

}

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

}

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

实现多层撤销：不要只是记录最后一个被执行的命令，而使用一个堆栈记录操作
过程的每一个命令。然后，不管什么时候按下了撤销按键，都可以从堆栈中取出最上层的
命令，然后调用它的undo方法。