3. 行为型模式 (6) 命令模式

3. 行为型模式 (6) 命令模式

命令模式（Command Pattern）以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

1. 命令模式

package com.andrew.pattern0306.command.model01;
public interface Order {
    void execute();
}

package com.andrew.pattern0306.command.model01;
public class Stock {
    private String name = "ABC";
    private int quantity = 10;
    public void buy() {
        System.out.println("Stock [ Name: " + name + ", Quantity: " + quantity + " ] bought");
    }
    public void sell() {
        System.out.println("Stock [ Name: " + name + ", Quantity: " + quantity + " ] sold");
    }
}

package com.andrew.pattern0306.command.model01;
public class BuyStock implements Order {
    private Stock abcStock;
    public BuyStock(Stock abcStock) {
        this.abcStock = abcStock;
    }
    public void execute() {
        abcStock.buy();
    }
}

package com.andrew.pattern0306.command.model01;
public class SellStock implements Order {
    private Stock abcStock;
    public SellStock(Stock abcStock) {
        this.abcStock = abcStock;
    }
    public void execute() {
        abcStock.sell();
    }
}

package com.andrew.pattern0306.command.model01;
import java.util.ArrayList;
import java.util.List;
public class Broker {
    private List<Order> orderList = new ArrayList<Order>();
    public void takeOrder(Order order) {
        orderList.add(order);
    }
    public void placeOrders() {
        for (Order order : orderList) {
            order.execute();
        }
        orderList.clear();
    }
}

package com.andrew.pattern0306.command.model01;
/**
 * 1. 命令模式
 * 
 * @author andrew
 * @date 2018/08/17
 */
public class Client {
    public static void main(String[] args) {
        Stock abcStock = new Stock();
        BuyStock buyStockOrder = new BuyStock(abcStock);
        SellStock sellStockOrder = new SellStock(abcStock);
        Broker broker = new Broker();
        broker.takeOrder(buyStockOrder);
        broker.takeOrder(sellStockOrder);
        broker.placeOrders();
    }
}
运行结果：
Stock [ Name: ABC, Quantity: 10 ] bought
Stock [ Name: ABC, Quantity: 10 ] sold

角色：
1. Command：定义命令的接口，声明执行的方法。
2. ConcreteCommand：命令接口实现对象，是“虚”的实现；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
3. Receiver：接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
4. Invoker：要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。
5. Client：创建具体的命令对象，并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端，而是在组装命令对象和接收者，或许，把这个Client称为装配者会更好理解，因为真正使用命令的客户端是从Invoker来触发执行。

2. 命令模式

package com.andrew.pattern0306.command.model02;
public interface Command {
    void execute();
}

package com.andrew.pattern0306.command.model02;
public class CommandOn implements Command {
    private Tv myTv;
    public CommandOn(Tv tv) {
        myTv = tv;
    }
    public void execute() {
        myTv.turnOn();
    }
}

package com.andrew.pattern0306.command.model02;
public class CommandOff implements Command {
    private Tv myTv;
    public CommandOff(Tv tv) {
        myTv = tv;
    }
    public void execute() {
        myTv.turnOff();
    }
}

package com.andrew.pattern0306.command.model02;
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);
    }
}

package com.andrew.pattern0306.command.model02;
public class Tv {
    public int currentChannel = 0;
    public void turnOn() {
        System.out.println("The tv is on.");
    }
    public void turnOff() {
        System.out.println("The tv is off.");
    }
    public void changeChannel(int channel) {
        this.currentChannel = channel;
        System.out.println("Now TV channel is " + channel);
    }
}

package com.andrew.pattern0306.command.model02;
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();
    }
}

package com.andrew.pattern0306.command.model02;
/**
 * 2. 命令模式
 * 
 * @author andrew
 * @date 2018/08/17
 */
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 tv is on.
Now TV channel is 2
The tv is off.