`

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.
分享到:
评论

相关推荐

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

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

    java 23种设计模式.zip

    设计模式主要分为三大类: 1.创建型模式:工厂模式、抽象...4.行为型模式:模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

    23种设计模式 (创建型,结构型,行为型)

    命令模式(Command Pattern) 15. 迭代器模式(Iterator Pattern) 行为型: 16. 观察者模式(Observer Pattern) 17. 解释器模式(Interpreter Pattern) 18. 中介者模式(Mediator Pattern) 19. 职责链模式...

    23种设计模式,创建型模式共5种,结构型模式7种,行为型模式11种

    2. **命令模式**:将请求封装为对象,使得可以使用不同的请求对客户端进行参数化,支持请求的队列处理和撤销操作。 3. **责任链模式**:在对象链中传递请求,由链上的对象决定是否处理该请求,使得系统可以在不影响...

    JAVA-设计模式-行为型模式-命令模式

    JAVA-设计模式-行为型模式-命令模式

    设计模式_行为型_命令模式.md

    命令模式是行为型设计模式之一,主要用来将请求或者操作封装成对象。它让发送者和接收者之间解耦,让不同的请求对客户进行参数化。命令模式可以将请求封装为对象,这意味着它们能够被存储、排队或记录日志,以及支持...

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

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

    设计模式3-行为型模式.doc

    在上述内容中,提到了七种行为型设计模式,分别是责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式。 1. **责任链模式**:责任链模式的核心是建立一个对象链,每个对象都有处理请求的能力,...

    c#设计模式 行为型模式 实验报告+源代码

    c#设计模式 行为型模式 包括8个设计模式的实验报告+源代码。实验报告包括实验类图和个人总结的一些小技巧,源代码...包括:职责链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式

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

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

    23种设计模式-行为型模式.docx

    在给定的文档中,提到了23种设计模式中的几种行为型模式,包括责任链模式、迭代器模式、中介者模式、命令模式、解释器模式、访问者模式、策略模式、模板方法模式、状态模式、观察者模式以及备忘录模式。下面将对这些...

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

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

    设计模式之行为型模式代码.zip

    命令模式将请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。在图形用户界面中,每个按钮点击事件都可看作一个命令对象。 9. **访问者模式**: ...

    C#新版设计模式手册[中文][共二卷][vol1]

    14.命令模式...................................................82 15.解释器模式.................................................89 16.迭代器模式.................................................95 17...

    新版设计模式手册 通俗的例子讲述设计的方法 1创建型模式 2结构型模式 3 行为模式 详细的设计说明

    这个“新版设计模式手册”深入浅出地介绍了设计模式的三大类:创建型模式、结构型模式和行为模式,为开发者提供了一套详细的设计说明。 一、创建型模式 创建型模式主要关注对象的创建过程,它们的目标是使得对象的...

    设计模式3-行为型模式

    **Chain of Responsibility(职责链)模式**是一种行为模式,它的主要动机是减少请求发送者与接收者之间的耦合。在软件开发中,有时一个请求可能由多个对象处理,但最终只有一个对象会真正处理这个请求。职责链模式...

    C#设计模式_设计模式_C#_

    命令模式(Command Pattern) 15. 迭代器模式(Iterator Pattern) 16. 观察者模式(Observer Pattern) 17. 解释器模式(Interpreter Pattern) 18. 中介者模式(Mediator Pattern) 19. 职责链模式(Chain of ...

    基于Python的行为型模式设计.zip

    3. **命令模式**:命令模式将请求封装为一个对象,使得可以使用不同的请求、队列请求、或者支持撤销操作。Python中,你可以通过定义命令类和调用者类来实现此模式。 4. **迭代器模式**:迭代器模式提供了一种方法来...

Global site tag (gtag.js) - Google Analytics