//將客人點(diǎn)餐的請(qǐng)求封裝為一個(gè)請(qǐng)求類
//即訂單類
public class Order
{
    //幾號(hào)桌點(diǎn)餐
    private  Integer diningTable;
    //當(dāng)前桌客人點(diǎn)的菜品
    private Map<String,Integer> FoodDic=new HashMap<>();
    public Integer getDiningTable() {
        return diningTable;
    }
    public void setDiningTable(Integer diningTable) {
        this.diningTable = diningTable;
    }
    public Map<String, Integer> getFoodDic() {
        return FoodDic;
    }
    public void setFoodDic(String foodName,Integer num)
    {
        FoodDic.put(foodName,num);
    }
}

//抽象命令類
public abstract class Command
{
    //執(zhí)行命令的抽象方法
    public abstract void execute();
}

//具體訂單命令
public class OrderCommand extends Command {
    //持有接受者對(duì)象和訂單對(duì)象
    private SeniorChef chef;
    private Order order;
    //通過構(gòu)造函數(shù)為屬性賦值
    OrderCommand(SeniorChef seniorChef,Order order)
    {
        this.chef=seniorChef;
        this.order=order;
    }
    //通過調(diào)用接受者對(duì)象的方法，來執(zhí)行命令的具體邏輯行為
    @Override
    public void execute()
    {
        System.out.println(order.getDiningTable()+"號(hào)桌的訂單");
        //遍歷集合: key-->foodName value--->食物點(diǎn)了幾份
        order.getFoodDic().forEach((key,value)->{
            chef.makeFood(key,value);
        });
    }
}

//廚師類
public class SeniorChef
{
    //制作食物
    public void makeFood(String name,Integer num)
    {
        System.out.println("制作"+name+"  "+num+"份");
    }
}

//服務(wù)員類----發(fā)送請(qǐng)求(命令)者
public class Waitor
{
      //命令可能有多個(gè)
    List<Command> commadns= Lists.newArrayList();
    //將命令放入到集合中
    public void setCmd(Command cmd)
    {
        commadns.add(cmd);
    }
    //發(fā)起命令功能
    public void OrderUp()
    {
        System.out.println("訂單來了.....");
        //遍歷List集合
        commadns.forEach(cmd->{
            if(cmd!=null)
                //命令有效就執(zhí)行
                cmd.execute();
        });
    }
}

        //創(chuàng)建訂單對(duì)象---請(qǐng)求被包裝成一個(gè)類
        Order order=new Order();
        order.setDiningTable(1);
        order.setFoodDic("大雞腿",2);
        //創(chuàng)建廚師對(duì)象---接收者
        SeniorChef chef=new SeniorChef();
        //創(chuàng)建命令類--組合接受者和具體請(qǐng)求
        Command command=new OrderCommand(chef,order);
        //創(chuàng)建服務(wù)員---調(diào)用者
        Waitor waitor=new Waitor();
        //將命令組合進(jìn)去
        waitor.setCmd(command);
        //執(zhí)行命令
        waitor.OrderUp();

public class Receiver {
    /**
     * 真正執(zhí)行命令相應(yīng)的操作
     */
    public void action(){
        System.out.println("執(zhí)行操作");
    }
}

public interface Command {
    /**
     * 執(zhí)行方法
     */
    void execute();
}

public class ConcreteCommand implements Command {
    //持有相應(yīng)的接收者對(duì)象
    private Receiver receiver = null;
    /**
     * 構(gòu)造方法
     */
    public ConcreteCommand(Receiver receiver){
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        //通常會(huì)轉(zhuǎn)調(diào)接收者對(duì)象的相應(yīng)方法，讓接收者來真正執(zhí)行功能
        receiver.action();
    }
}

public class Invoker {
    /**
     * 持有命令對(duì)象
     */
    private Command command = null;
    /**
     * 構(gòu)造方法
     */
    public Invoker(Command command){
        this.command = command;
    }
    /**
     * 行動(dòng)方法
     */
    public void action(){
        command.execute();
    }
}

public class Client {
    public static void main(String[] args) {
        //創(chuàng)建接收者
        Receiver receiver = new Receiver();
        //創(chuàng)建命令對(duì)象，設(shè)定它的接收者
        Command command = new ConcreteCommand(receiver);
        //創(chuàng)建請(qǐng)求者，把命令對(duì)象設(shè)置進(jìn)去
        Invoker invoker = new Invoker(command);
        //執(zhí)行方法
        invoker.action();
    }
}

public interface MacroCommand extends Command {
    /**
     * 宏命令聚集的管理方法
     * 可以添加一個(gè)成員命令
     */
    public void add(Command cmd);
    /**
     * 宏命令聚集的管理方法
     * 可以刪除一個(gè)成員命令
     */
    public void remove(Command cmd);
}

public class MacroAudioCommand implements MacroCommand {
    private List<Command> commandList = new ArrayList<Command>();
    /**
     * 宏命令聚集管理方法
     */
    @Override
    public void add(Command cmd) {
        commandList.add(cmd);
    }
    /**
     * 宏命令聚集管理方法
     */
    @Override
    public void remove(Command cmd) {
        commandList.remove(cmd);
    }
    /**
     * 執(zhí)行方法
     */
    @Override
    public void execute() {
        for(Command cmd : commandList){
            cmd.execute();
        }
    }
}

public class Julia {
    public static void main(String[]args){
        //創(chuàng)建接收者對(duì)象
        AudioPlayer audioPlayer = new AudioPlayer();
        //創(chuàng)建命令對(duì)象
        Command playCommand = new PlayCommand(audioPlayer);
        Command rewindCommand = new RewindCommand(audioPlayer);
        Command stopCommand = new StopCommand(audioPlayer);
        MacroCommand marco = new MacroAudioCommand();
        marco.add(playCommand);
        marco.add(rewindCommand);
        marco.add(stopCommand);
        marco.execute();
    }
}

//命令接口(抽象命令角色)
public interface Runnable {
    public abstract void run();
}
​
//調(diào)用者
public class Thread implements Runnable {
    private Runnable target;
    public synchronized void start() {
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
​
        group.add(this);
​
        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
            }
        }
    }
    private native void start0();
}

/**
 * jdk Runnable 命令模式
 *      TurnOffThread ： 屬于具體
 */
public class TurnOffThread implements Runnable{
     private Receiver receiver;
     public TurnOffThread(Receiver receiver) {
        this.receiver = receiver;
     }
     public  void run() {
        receiver.turnOFF();
     }

**
 * 測(cè)試類
 */
public class Demo {
     public static void main(String[] args) {
         Receiver receiver = new Receiver();
         TurnOffThread turnOffThread = new TurnOffThread(receiver);
         Thread thread = new Thread(turnOffThread);
         thread.start();
     }
}