`

行为型模式--命令模式(Command)

阅读更多

命令模式很好理解,举个例子,司令员下令让士兵去干件事情,从整个事情的角度来考虑,司令员的作用是,发出口令,口令经过传递,传到了士兵耳朵里,士兵去执行。这个过程好在,三者相互解耦,任何一方都不用去依赖其他人,只需要做好自己的事儿就行,司令员要的是结果,不会去关注到底士兵是怎么实现的。我们看看关系图:

Invoker是调用者(司令员),Receiver是被调用者(士兵),MyCommand是命令,实现了Command接口,持有接收对象,看实现代码:

[java] view plaincopy
  1. public interface Command {  
  2.     public void exe();  
  3. }  
[java] view plaincopy
  1. public class MyCommand implements Command {  
  2.   
  3.     private Receiver receiver;  
  4.       
  5.     public MyCommand(Receiver receiver) {  
  6.         this.receiver = receiver;  
  7.     }  
  8.   
  9.     @Override  
  10.     public void exe() {  
  11.         receiver.action();  
  12.     }  
  13. }  
[java] view plaincopy
  1. public class Receiver {  
  2.     public void action(){  
  3.         System.out.println("command received!");  
  4.     }  
  5. }  
[java] view plaincopy
  1. public class Invoker {  
  2.       
  3.     private Command command;  
  4.       
  5.     public Invoker(Command command) {  
  6.         this.command = command;  
  7.     }  
  8.   
  9.     public void action(){  
  10.         command.exe();  
  11.     }  
  12. }  
[java] view plaincopy
  1. public class Test {  
  2.   
  3.     public static void main(String[] args) {  
  4.         Receiver receiver = new Receiver();  
  5.         Command cmd = new MyCommand(receiver);  
  6.         Invoker invoker = new Invoker(cmd);  
  7.         invoker.action();  
  8.     }  
  9. }  

输出:command received!

 

=========================================================
下面是command的另外一个例子:

public class test {

	public static void main(String[] args) {

		Player player = new Player();
		TurnOnCommand on = new TurnOnCommand(player);
		TurnOffCommand off = new TurnOffCommand(player);
		NextCommand next = new NextCommand(player);

		PlayerInvoker invoker = new PlayerInvoker(on, off, next);
		invoker.turnOn();
		invoker.turnOff();
		invoker.next();
	}
}

class Player {

	public void turnOn() {

		System.out.println("打开");
	}

	public void turnOff() {
		System.out.println("关闭");

	}

	public void next() {

		System.out.println("下一曲");
	}
}

interface Command {

	public void execute();
}

class TurnOnCommand implements Command {

	private Player player;

	public TurnOnCommand(Player player) {
		this.player = player;
	}

	public void execute() {
		this.player.turnOn();
	}

}

class TurnOffCommand implements Command {

	private Player player;

	public TurnOffCommand(Player player) {
		this.player = player;
	}

	public void execute() {
		this.player.turnOff();
	}

}

// 下一曲命令类
class NextCommand implements Command {

	private Player player;

	public NextCommand(Player player) {
		this.player = player;
	}

	public void execute() {
		this.player.next();
	}

}

class PlayerInvoker {

	private TurnOnCommand on;
	private TurnOffCommand off;
	private NextCommand next;

	public PlayerInvoker(TurnOnCommand on, TurnOffCommand off, NextCommand next) {
		this.on = on;
		this.off = off;
		this.next = next;
	}

	public void turnOn() {
		this.on.execute();
	}

	public void turnOff() {
		this.off.execute();
	}

	public void next() {
		this.next.execute();
	}
}

 ======================================================

2、

3.代码

复制代码
public interface Command {
    public void execute();
}


public class ConcreteCommand implements Command {

    private Receiver receiver = null;
    private String state;

    public ConcreteCommand(Receiver receiver){
       this.receiver = receiver;
    }  
    public void execute() {
       receiver.action();
    }
}


public class Receiver {
    public void action(){
       //真正执行命令操作的功能代码
    }
}


public class Invoker {
    private Command command = null;

    public void setCommand(Command command) {
       this.command = command;
    }

    public void runCommand() {
       command.execute();
    }
}

public class Client {
    public void assemble(){
       //创建接收者
       Receiver receiver = new Receiver();
       //创建命令对象,设定它的接收者
       Command command = new ConcreteCommand(receiver);
       //创建Invoker,把命令对象设置进去
       Invoker invoker = new Invoker();
       invoker.setCommand(command);
    }
}
复制代码
复制代码
下面给个例子,是模拟对电视机的操作有开机、关机、换台命令。代码如下

//命令接收者
public class Tv {
  public int currentChannel = 0;

  public void turnOn() {
     System.out.println("The televisino is on.");
  }

  public void turnOff() {
     System.out.println("The television is off.");
  }

  public void changeChannel(int channel) {
     this.currentChannel = channel;
     System.out.println("Now TV channel is " + channel);
  }
}

//执行命令的接口
public interface Command {
  void execute();
}

//开机命令
public class CommandOn implements Command {
  private Tv myTv;

  public CommandOn(Tv tv) {
     myTv = tv;
  }

  public void execute() {
     myTv.turnOn();
  }
}

//关机命令
public class CommandOff implements Command {
  private Tv myTv;

  public CommandOff(Tv tv) {
     myTv = tv;
  }

  public void execute() {
     myTv.turnOff();
  }
}

//频道切换命令
public class CommandChange implements Command {
  private Tv myTv;

  private int channel;

  public CommandChange(Tv tv, int channel) {
     myTv = tv;
     this.channel = channel;
  }

  public void execute() {
     myTv.changeChannel(channel);
  }
}

//可以看作是遥控器吧
public class Control {
  private Command onCommand, offCommand, changeChannel;

  public Control(Command on, Command off, Command channel) {
     onCommand = on;
     offCommand = off;
     changeChannel = channel;
  }

  public void turnOn() {
     onCommand.execute();
  }

  public void turnOff() {
     offCommand.execute();
  }

  public void changeChannel() {
     changeChannel.execute();
  }
}

//测试类
public class Client {
  public static void main(String[] args) {
     // 命令接收者
     Tv myTv = new Tv();
     // 开机命令
     CommandOn on = new CommandOn(myTv);
     // 关机命令
     CommandOff off = new CommandOff(myTv);
     // 频道切换命令
     CommandChange channel = new CommandChange(myTv, 2);
     // 命令控制对象
     Control control = new Control(on, off, channel);

     // 开机
     control.turnOn();
     // 切换频道
     control.changeChannel();
     // 关机
     control.turnOff();
  }
}


执行结果为:
The televisino is on.
Now TV channel is 2
The television is off.
复制代码

4.应用场景

分享到:
评论

相关推荐

    c++设计模式-行为型模式-命令模式

    c++设计模式-行为型模式-命令模式;qt工程 ;c++简单源码; 命令(Command)模式的定义如下:将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通,这样方便将...

    (行为型模式) Command 命令模式

    ### (行为型模式) Command 命令模式 #### 概述 在软件工程领域,设计模式被广泛地应用于解决常见的编程难题。其中,“Command”(命令)模式是一种行为型设计模式,它允许将请求封装成对象,从而使你能够用不同的...

    设计模式----命令模式

    在命令模式中,主要涉及到四个角色:客户端(Client)、命令接口(Command Interface)、具体命令(Concrete Command)和接收者(Receiver)。客户端创建具体命令对象并设置其接收者,然后将命令对象传递给调用者...

    设计模式-command

    命令模式是一种行为设计模式,它的主要目的是将命令的发送者与接收者解耦。在“设计模式-command”中,我们看到这个模式的应用,通过将一个操作封装为一个对象(即命令对象),使得发送者可以无需知道接收者的具体...

    设计模式专题之(十四)命令模式---设计模式命令模式示例代码(python--c++)

    命令模式是一种行为设计模式,它将请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。在本专题中,我们将深入探讨命令模式,并通过Python和C++两种...

    Go-command-Go命令模式用于线程安全的串行和并行调度程序

    Go语言中的`command`通常指的是命令模式,这是一种行为设计模式,它封装了对象的状态和行为,并将它们作为命令参数传递,使得请求可以被异步执行。在Go这种并发编程非常强大的语言中,命令模式有着广泛的应用,特别...

    c++-设计模式之命令模式(Command Pattern)

    命令模式(Command Pattern)是一种行为型设计模式,它将请求封装为对象,从而使您可以使用不同的请求、队列请求或日志请求,并支持可撤销操作。命令模式通常用于实现操作的解耦,使得发送者和接收者之间不直接关联...

    命令模式(Command模式)

    命令模式是一种行为设计模式,它将请求封装为一个对象,使得我们可以使用不同的请求、队列或者记录请求日志,还可以支持可撤销的操作。在命令模式中,我们创建表示各种操作的类以及能执行这些操作的对象。这种模式的...

    [行为型模式]命令模式的理解

    命令模式是一种行为设计模式,它将请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。在软件工程中,这种模式常用于解耦发出命令的对象(调用者)与...

    设计模式之命令模式(Command Pattern)

    命令模式是一种行为设计模式,它将请求封装成独立的对象,使得可以使用不同的请求、队列请求、记录请求历史以及支持可撤销的操作。这种模式在软件工程中被广泛应用,尤其是在需要解耦请求发起者和接收者时,提高了...

    设计模式-COMMAND

    **命令模式(Command Pattern)** 是一种行为设计模式,它将请求封装成对象,从而使你能够用不同的请求对客户端进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。 在软件开发中,特别是面向对象编程语言...

    设计模式--命令模式java例子

    命令模式是一种行为设计模式,它将请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。在Java编程中,命令模式的应用广泛且实用。 命令模式的核心是将...

    设计模式之Command(命令)模式

    此外,"Command模式.ppt"和"Command模式.docx"可能包含了对命令模式更深入的理论解释和示例代码,帮助学习者理解其原理和应用。 总之,Command模式通过将操作封装在独立的类中,提高了代码的可读性和可维护性,同时...

    C#面向对象设计模式纵横谈(15):(行为型模式) Command 命令模式 (Level 300)

    命令模式是一种行为设计模式,它将请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。在C#编程中,这种模式常用于解耦调用者和接收者,提高代码的灵活...

    设计模式3-行为型模式

    **Command(命令)模式**则是另一种行为模式,它的目的是将行为请求者和行为实现者解耦。在需要记录、撤销或重做行为的场景中,命令模式尤为有用。它将行为封装为独立的对象,使得请求可以被参数化,可以进行队列...

    设计模式之命令模式(Command)

    命令模式是一种行为设计模式,它的主要目的是将请求者与接收者解耦,使得请求的发起者无需知道哪个对象会执行这个请求,同时也让系统更容易扩展。这种模式在软件工程中广泛应用,特别是在事件驱动和分布式系统中。 ...

    设计模式-命令模式

    命令模式是一种行为设计模式,它将请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。在iOS开发中,命令模式尤其适用于处理事件驱动的编程场景,因为...

    C#面向对象设计模式纵横谈\15 行为型模式Command命令模式.zip

    在这里与各位分享本人从网络上下载的C#面向对象设计模式纵横谈系列视频,共有25节,除了第一节需要各位贡献一点资源分以作为对本人上传资源的回馈,后面的其他资源均不需要... 这是第15节:行为型模式Command命令模式

    Command 命令模式

    命令模式是一种行为设计模式,它将请求封装为一个对象,使得你可以使用不同的请求、队列请求、或者记录请求日志。在软件工程中,命令模式的应用广泛,尤其是在处理事件驱动系统或者需要解耦调用者与被调用者时。这种...

    设计模式-命令模式(C#)代码

    命令模式是一种行为设计模式,它将请求封装为一个对象,从而使你可用不同的请求对客户进行参数化,对请求排队或记录请求日志,以及支持可撤销的操作。在C#编程中,命令模式的应用广泛且实用。 命令模式的核心结构...

Global site tag (gtag.js) - Google Analytics