在物件導向程式設計的範疇中，**命令模式**（英語：**Command pattern**）是一種設計模式，它嘗試以物件來代表實際行動。命令物件可以把行動(action) 及其參數封裝起來，於是這些行動可以被：

* 重複多次
* 取消（如果該物件有實作的話）
* 取消後又再重做

這些都是現代大型應用程式所必須的功能，即「復原」及「重複」。除此之外，可以用命令模式來實作的功能例子還有：

* 交易行為
* 進度列
* 精靈
* 使用者介面按鈕及功能表項目
* 執行緒 pool
* 巨集收錄

結構
--

範例
--

### C#

```
using System;
using System.Collections.Generic;

namespace CommandPattern
{
 public interface ICommand
 {
 void Execute();
 }

 /\* The Invoker class \*/
 public class Switch
 {
 private List<ICommand> \_commands = new List<ICommand>();

 public void StoreAndExecute(ICommand command)
 {
 \_commands.Add(command);
 command.Execute();
 }
 }

 /\* The Receiver class \*/
 public class Light
 {
 public void TurnOn()
 {
 Console.WriteLine("The light is on");
 }

 public void TurnOff()
 {
 Console.WriteLine("The light is off");
 }
 }

 /\* The Command for turning on the light - ConcreteCommand #1 \*/
 public class FlipUpCommand : ICommand
 {
 private Light \_light;

 public FlipUpCommand(Light light)
 {
 \_light = light;
 }

 public void Execute()
 {
 \_light.TurnOn();
 }
 }

 /\* The Command for turning off the light - ConcreteCommand #2 \*/
 public class FlipDownCommand : ICommand
 {
 private Light \_light;

 public FlipDownCommand(Light light)
 {
 \_light = light;
 }

 public void Execute()
 {
 \_light.TurnOff();
 }
 }

 /\* The test class or client \*/
 internal class Program
 {
 public static void Main(string[] args)
 {
 Light lamp = new Light();
 ICommand switchUp = new FlipUpCommand(lamp);
 ICommand switchDown = new FlipDownCommand(lamp);

 Switch s = new Switch();
 string arg = args.Length > 0 ? args[0].ToUpper() : null;
 if (arg == "ON")
 {
 s.StoreAndExecute(switchUp);
 }
 else if (arg == "OFF")
 {
 s.StoreAndExecute(switchDown);
 }
 else
 {
 Console.WriteLine("Argument \"ON\" or \"OFF\" is required.");
 }
 }
 }
}

```

### Java

```
import java.util.List;
import java.util.ArrayList;

/\* The Command interface \*/
public interface Command {
 void execute();
}

/\* The Invoker class \*/
public class Switch {
 private List<Command> history = new ArrayList<Command>();

 public Switch() {
 }

 public void storeAndExecute(Command cmd) {
 this.history.add(cmd); // optional 
 cmd.execute(); 
 }
}

/\* The Receiver class \*/
public class Light {
 public Light() {
 }

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

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

/\* The Command for turning on the light - ConcreteCommand #1 \*/
public class FlipUpCommand implements Command {
 private Light theLight;

 public FlipUpCommand(Light light) {
 this.theLight = light;
 }

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

/\* The Command for turning off the light - ConcreteCommand #2 \*/
public class FlipDownCommand implements Command {
 private Light theLight;

 public FlipDownCommand(Light light) {
 this.theLight = light;
 }

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

/\* The test class or client \*/
public class PressSwitch {
 public static void main(String[] args){
 Light lamp = new Light();
 Command switchUp = new FlipUpCommand(lamp);
 Command switchDown = new FlipDownCommand(lamp);

 Switch mySwitch = new Switch();

 try {
 if ("ON".equalsIgnoreCase(args[0])) {
 mySwitch.storeAndExecute(switchUp);
 }
 else if ("OFF".equalsIgnoreCase(args[0])) {
 mySwitch.storeAndExecute(switchDown);
 }
 else {
 System.out.println("Argument \"ON\" or \"OFF\" is required.");
 }
 } catch (Exception e) {
 System.out.println("Arguments required.");
 }
 }
}

```

### Python

```
class Switch(object):
 """The INVOKER class"""
    def \_\_init\_\_(self, flip\_up\_cmd, flip\_down\_cmd):
        self.flip\_up = flip\_up\_cmd
        self.flip\_down = flip\_down\_cmd

class Light(object):
 """The RECEIVER class"""
    def turn\_on(self):
        print("The light is on")
    def turn\_off(self):
        print("The light is off")

class LightSwitch(object):
 """The CLIENT class"""
    def \_\_init\_\_(self):
        lamp = Light()
        self.\_switch = Switch(lamp.turn\_on, lamp.turn\_off)

    def switch(self, cmd):
        cmd = cmd.strip().upper()
        if cmd == "ON":
            self.\_switch.flip\_up()
        elif cmd == "OFF":
            self.\_switch.flip\_down()
        else:
            print("Argument 'ON' or 'OFF' is required.")

# Execute if this file is run as a script and not imported as a module
if \_\_name\_\_ == "\_\_main\_\_":
    light\_switch = LightSwitch()
    print("Switch ON test.")
    light\_switch.switch("ON")
    print("Switch OFF test.")
    light\_switch.switch("OFF")
    print("Invalid Command test.")
    light\_switch.switch("\*\*\*\*")

```

### Scala

```
/\* The Command interface \*/
trait Command {
 def execute()
}
 
/\* The Invoker class \*/
class Switch {
 private var history: List[Command] = Nil
 
 def storeAndExecute(cmd: Command) {
 cmd.execute()
 this.history :+= cmd
 }
}
 
/\* The Receiver class \*/
class Light {
 def turnOn() = println("The light is on")
 def turnOff() = println("The light is off")
}
 
/\* The Command for turning on the light - ConcreteCommand #1 \*/
class FlipUpCommand(theLight: Light) extends Command {
 def execute() = theLight.turnOn()
}
 
/\* The Command for turning off the light - ConcreteCommand #2 \*/
class FlipDownCommand(theLight: Light) extends Command {
 def execute() = theLight.turnOff()
}
 
/\* The test class or client \*/
object PressSwitch {
 def main(args: Array[String]) {
 val lamp = new Light()
 val switchUp = new FlipUpCommand(lamp)
 val switchDown = new FlipDownCommand(lamp)
 
 val s = new Switch()
 
 try {
 args(0).toUpperCase match {
 case "ON" => s.storeAndExecute(switchUp)
 case "OFF" => s.storeAndExecute(switchDown)
 case \_ => println("Argument \"ON\" or \"OFF\" is required.")
 }
 } catch {
 case e: Exception => println("Arguments required.")
 }
 }
}

```

### Javascript

```
/\* The Invoker function \*/
var Switch = function(){
 var \_commands = [];
 this.storeAndExecute = function(command){
 \_commands.push(command);
 command.execute();
 }
}

/\* The Receiver function \*/
var Light = function(){
 this.turnOn = function(){ console.log ('turn on')};
 this.turnOff = function(){ console.log ('turn off') };
}

/\* The Command for turning on the light - ConcreteCommand #1 \*/
var FlipUpCommand = function(light){
 this.execute = light.turnOn;
}

/\* The Command for turning off the light - ConcreteCommand #2 \*/
var FlipDownCommand = function(light){
 this.execute = light.turnOff;
}

var light = new Light();
var switchUp = new FlipUpCommand(light);
var switchDown = new FlipDownCommand(light);
var s = new Switch();

s.storeAndExecute(switchUp);
s.storeAndExecute(switchDown);

```

  

### C++

```
class ICommand
{
 public:
 virtual void Execute() = 0;
};

class Swicher
{
 private:
 std::vector<ICommand \*> \_commands;

 public:
 void StoreAndExecute(ICommand \*command)
 {
 if (command){
 \_commands.push\_back(command);
 command->Execute();
 }
 }
};

class Light
{
 public:
 void TurnOn()
 {
 std::cout<<"The light is on."<<std::endl;
 }

 void TurnOff()
 {
 std::cout << "The light is off." << std::endl;
 }
};

/\* The Command for turning on the light - ConcreteCommand #1 \*/
class FlipUpCommand : public ICommand
{
 private:
 Light \*\_light;

 public:
 FlipUpCommand(Light \*light)
 {
 \_light = light;
 }

 void Execute()
 {
 \_light->TurnOn();
 }
};

/\* The Command for turning off the light - ConcreteCommand #2 \*/
class FlipDownCommand : public ICommand
{
 private:
 Light \*\_light;

 public:
 FlipDownCommand(Light \*light)
 {
 \_light = light;
 }

 void Execute()
 {
 \_light->TurnOff();
 }
};

int main()
{
 Light \*light = new Light();
 ICommand \*switchOn = dynamic\_cast<ICommand \*>(new FlipUpCommand(light));
 ICommand \*switchDown = dynamic\_cast<ICommand \*>(new FlipDownCommand(light));

 Swicher \*switcher = new Swicher();
 switcher->StoreAndExecute(switchOn);
 switcher->StoreAndExecute(switchDown);

 delete switcher;
 delete switchOn;
 delete switchDown;
 delete light;
}

```

|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
软件设计模式 |
| --- |
|  |
| 设计模式 | 

|  |  |
| --- | --- |
| 创建型 | 
* 抽象工厂
* 生成器
* 工厂方法
* 惰性初始
* 原型
* 单例

 |
|  |
| 结构型 | 
* 适配器
* 桥接
* Composite（英语：）
* 修饰
* 外观
* 享元
* 代理

 |
|  |
| 行为型 | 
* 责任链
* 命令
* Interpreter（英语：）
* 迭代器
* 中介者
* Memento（英语：）
* 观察者
* Specification（英语：）
* State（英语：）
* 策略
* 模板方法
* 访问者

 |

 |
|  |
| 并行模式 | 
* 主动对象（英语：）
* 阻止（英语：）
* Binding properties（英语：）
* 双重检查锁定模式
* 异步方法调用
* Future与promise
* Guarded suspension（英语：）
* Join（英语：）
* 锁
* Messaging（英语：）
* 监视器
* Proactor（英语：）
* 反应器
* 读写锁
* 调度
* 线程池
* 线程局部存储

 |
|  |
| 架构模式 | 
* ADR（英语：）
* 主动记录
* Broker（英语：）
* 主從式架構
* cbd
* DAO
* DDD
* Data transfer object（英语：）
* Front controller（英语：）
* Identity map（英语：）
* Interceptor（英语：）
* 控制反转
* MVC
* 微服務
* MVP
* 單體式應用程式
* 多层架构
* *n*-tier（英语：）
* Naked objects（英语：）
* P2P
* 发布/订阅
* REST
* SOA
* Specification（英语：）

 |
|  |
| 云分布式 | 
* 断路器
* CQRS（英语：）
* 补偿交易（英语：）
* 索引表
* 领导者选举（英语：）
* MapReduce
* 物化视图（英语：）
* 管道
* 过滤器（英语：）
* 发布/订阅
* 分片（英语：）
* 节流（英语：）

 |
|  |
| 其他模式 | 
* Blackboard（英语：）
* Business delegate（英语：）
* Composite entity（英语：）
* 委托
* 依赖注入
* Intercepting filter（英语：）
* 惰性載入
* Method chaining（英语：）
* 模拟对象
* 空对象
* 对象池
* Servant（英语：）
* Twin（英语：）
* Type tunnel（英语：）

 |
|  |
| 书籍 | 
* 设计模式：可复用面向对象软件的基础
* 企业集成模式（英语：）

 |
|  |
| 人物 | 
* 克里斯托佛·亚历山大
* 埃里希·伽瑪
* Ralph Johnson（英语：）
* John Vlissides（英语：）
* 葛來迪·布區
* 肯特·貝克
* 沃德·坎宁安
* 马丁·福勒
* Robert Martin（英语：）
* Jim Coplien（英语：）
* Douglas Schmidt（英语：）
* Linda Rising

 |
|  |
| 社区 | 
* The Hillside Group（英语：）
* The Portland Pattern Repository（英语：）

 |

 |