1.概述：
在软件系统中，“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合，比如要对行为进行“记录、撤销/重做、事务”等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将“行为请求者”与“行为实现者”解耦？将一组行为抽象为对象，实现二者之间的松耦合。这就是命令模式（Command
Pattern）
2.模式结构：
3.模式分析：
4.模式优点：
5.模式缺点：
使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个命令都需要设计一个具体命令类，因此某些系统可能需要大量具体命令类，这将影响命令模式的使用。
6.使用环境：
下面是例子：
电视机实例:
1.Command:
public interface Icommand {
public void execute();
}
2.ConcreteCommand:
有三个：每个具体的命令都有一个命令执行者的对象(TV)
1.public class CommandOn implements Icommand{
TV tv = null;
public CommandOn(TV tv){
this.tv = tv;
}
public void execute()
{
tv.On();
}
}
2.public class CommandChang implements Icommand{
TV tv = null;
public CommandChang(TV tv){
this.tv = tv;
}
public void execute()
{
tv.Chang();
}
}
3.public class CommandOff implements Icommand{
TV tv = null;
public CommandOff(TV tv){
this.tv = tv;
}
public void execute()
{
tv.Off();
}
}
3.Receiver:
真正的命令执行者
public class TV {
public void On()
{
System.out.println("TV ON");
}
public void Chang()
{
System.out.println("TV CHANG");
}
public void Off()
{
System.out.println("TV OFF");
}
}
4.Invoker：
有三个具体的命令对象，执行命令请求。
public class CommandManager {
CommandOn cdOn = null;
CommandChang cdChang = null;
CommandOff cdOff = null;
public void SetCommand(CommandOn cmd1,CommandChang cmd2,CommandOff cmd3)
{
cdOn = cmd1;
cdChang = cmd2;
cdOff = cmd3;
}
public void On()
{
cdOn.execute();
}
public void Chang()
{
cdChang.execute();
}
public void Off()
{
cdOff.execute();
}
}
5.Client:
public class Command {
public static void main(String[] args)
{
TV tv = new TV();
CommandOn cmdOn = new CommandOn(tv);
CommandChang cmdChang = new CommandChang(tv);
CommandOff cmdOff = new CommandOff(tv);
CommandManager cmdManeger = new CommandManager();
cmdManeger.SetCommand(cmdOn, cmdChang, cmdOff);
cmdManeger.On();
cmdManeger.Chang();
cmdManeger.Off();
}
当然，如果改进一下：
4.Invoker：将命令对象作为一个参数传进来：
public class CommandManager {
public void execute(Icommand cmd)
{
cmd.execute();
}
}
5
5.Client:
public class Command {
public static void main(String[] args)
{
CommandManager cmdManager = new CommandManager();
cmdManager.execute(new CommandOn(new TV()));
cmdManager.execute(new CommandChang(new TV()));
cmdManager.execute(new CommandOff(new TV()));
}
还可以将Receiver和Invoker用同一个对象表示：
1.Command:
public interface Icommand {
public void execute(CommandManager cmdManager);
}
2.ConcreteCommand:
有三个：每个具体的命令都有一个命令执行者的对象(TV)
1.public class CommandOn implements Icommand{
public void execute(CommandManager cmdManager)
{
cmdManager.On();
}
}
2.public class CommandChang implements Icommand{
public void execute(CommandManager cmdManager)
{
cmdManager.Chang();
}
}
3.public class CommandOff implements Icommand{
public void execute(CommandManager cmdManager)
{
cmdManager.Off();
}
}
3.Receiver and Invoker：
有三个具体的命令对象，执行命令请求。
public class CommandManager {
public void On()
{
System.out.println("ON!!");
}
public void Chang()
{
System.out.println("CHANG!!");
}
public void Off()
{
System.out.println("OFF!!");
}
public void execute(Icommand cmd)
{
cmd.execute(this);
}
}
5.Client:
public class Command {
public static void main(String[] args)
{
CommandManager cmdManager = new CommandManager();
cmdManager.execute(new CommandOn());
cmdManager.execute(new CommandChang());
cmdManager.execute(new CommandOff());
}
当然这样就又把命令的请求者和接受者和在一起了。在对松耦合没有太严格要求的系统中，可以采用。