Modo de comando (Comando)----modo de diseño

Modo de comando (Comando)----modo de diseño

El modo de comando, en términos simples, es desacoplar el "solicitante de la acción de comando" y el "ejecutor de la acción de comando", y requiere que la solicitud se pueda deshacer.

El modo de comando se puede ver en todas partes en la vida:

El jefe emite una orden, no directamente a los empleados, sino a la secretaria. La forma de ejecutar la orden se entrega a la secretaria para que la complete, o un control remoto multipropósito con muchos botones de interruptores para electrodomésticos . esta vez puede controlar todos los aparatos eléctricos a través de este control remoto, y los interruptores de aparatos eléctricos específicos no están directamente relacionados con usted...

¿Qué es el modo de comando?

Patrón de comando, en el diseño de software, a menudo necesitamos enviar solicitudes a ciertos objetos, pero no sabemos quién es el destinatario de la solicitud o qué operación se solicita. Solo necesitamos ejecutar el programa al especificar un receptor de solicitud específico. , puede usar el modo de comando para diseñar.

El modo de comando permite que el remitente de la solicitud y el receptor de la solicitud eliminen el acoplamiento entre ellos, flexibilicen la relación de llamada entre los objetos y logren el desacoplamiento.

En el modo de comando, una solicitud se encapsula como un objeto, de modo que se pueden usar diferentes parámetros para representar diferentes solicitudes (es decir, comandos), y el modo de comando también admite operaciones de deshacer.

Debería haber algunos amigos que se sientan confundidos. De hecho, yo también estaba muy confundido al principio. Veamos el proceso de implementación de un control remoto multiuso específico. Puede ser claro~

Varias secciones en modo comando

1. Dominio:

   Defina la interfaz del comando y declare el método de ejecución.

2. ConcreteCommand (en la siguiente demostración, las acciones de cambio de luces y televisores son todas así):

   La interfaz de comando implementa el objeto, que es una implementación "virtual"; por lo general, contiene el receptor e invoca la función del receptor para completar la operación que debe realizar el comando.

3. Receptor (receptor de luz, receptor de TV):

   Receptor, el objeto que realmente ejecuta el comando. Cualquier clase puede ser un receptor, siempre que pueda implementar la función correspondiente que requiere el comando.

   Por lo general, se agrega en ConcreteCommand .

4. Invocador (controlador remoto):

   El objeto de comando es necesario para ejecutar la solicitud, que generalmente contiene el objeto de comando y puede contener muchos objetos de comando. Aquí es donde el cliente activa el comando y le pide que realice la acción correspondiente, lo que equivale a usar la entrada del objeto de comando.

5. Cliente:

   Cree un objeto de comando específico y establezca el receptor del objeto de comando. Tenga en cuenta que este no es un cliente en nuestro sentido convencional, sino que está ensamblando el objeto de comando y el receptor. Tal vez, sea mejor llamar a este Cliente ensamblador, porque el cliente que realmente usa el comando se activa desde el Invocador.

Diagrama de clase para patrón de comando

Realización de estuches de control remoto multiusos

interfaz de comando

package com.design_patterns.command;

//创建命令接口
public interface Command {
    
    

    //执行动作(操作)
    public void execute();
    //撤销动作(操作)
    public void undo();

}

LightOnCommand luz en la clase de ejecución

package com.design_patterns.command;

public class LightOnCommand implements Command {
    
    

    private LightReceiver lightReceiver;

    //构造方法

    public LightOnCommand(LightReceiver lightReceiver) {
    
    
        this.lightReceiver = lightReceiver;
    }

    //聚合LightReceiver
    @Override
    public void execute() {
    
    
         //调用接收者的方法
        lightReceiver.on();
    }

    @Override
    public void undo() {
    
    
        //调用接收者的方法
        lightReceiver.off();
    }
}

LightOffCommand apaga la clase de ejecución

package com.design_patterns.command;

public class LightOffCommand implements Command {
    
    

    private LightReceiver lightReceiver;

    //构造方法
    public LightOffCommand(LightReceiver lightReceiver) {
    
    
        this.lightReceiver = lightReceiver;
    }

    //执行关闭的方法
    @Override
    public void execute() {
    
    
        this.lightReceiver.off();
    }


    //执行撤销命令
    @Override
    public void undo() {
    
    
        this.lightReceiver.on();
    }
}

Clase de ejecución abierta TVOnCommand TV

package com.design_patterns.command;

public class TVOnCommand implements Command {
    
    

    //聚合tv接收者
    private TVReceiver tvReceiver;

    //通过构造方法传递进来实际的tv接收者
    public TVOnCommand(TVReceiver tvReceiver) {
    
    
        this.tvReceiver = tvReceiver;
    }

    @Override
    public void execute() {
    
    
        //使接收者执行动作命令
        this.tvReceiver.on();
    }

    @Override
    public void undo() {
    
    
        //撤回操作
        this.tvReceiver.off();
    }
}

NoCommand Sin clase de comando, utilizada para inicializar operaciones

package com.design_patterns.command;


/**
 * 无任何命令，即空执行。
 * 用于初始化每个按钮，当调用空命令时，对象什么都不做
 * 其实，这样也是一种设计模式，可以省略对空命令的判断
 */
public class NoCommand implements Command {
    
    
    @Override
    public void execute() {
    
    

    }

    @Override
    public void undo() {
    
    

    }
}

TVOffCommand TV fuera de la clase de ejecución

package com.design_patterns.command;

public class TVOffCommand implements Command {
    
    

    private TVReceiver tvReceiver;

    public TVOffCommand(TVReceiver tvReceiver) {
    
    
        this.tvReceiver = tvReceiver;
    }

    @Override
    public void execute() {
    
    
        this.tvReceiver.off();
    }

    @Override
    public void undo() {
    
    
        this.tvReceiver.on();
    }
}

Clase de receptor de luz LightReceiver

package com.design_patterns.command;

public class LightReceiver {
    
    

    public void on(){
    
    
        System.out.println("电灯打开了!");
    }

    public  void off(){
    
    
        System.out.println("电灯关闭了!");
    }
}

TVReceiver Clase de receptor de TV

package com.design_patterns.command;

public class TVReceiver {
    
    

    public void on(){
    
    
        System.out.println("电视TV打开了！");
    }

    public void off(){
    
    
        System.out.println("电视TV关闭了！");
    }
}

La clase de control remoto multipropósito del invocador que solicita RemoteController

package com.design_patterns.command;

public class RemoteController {
    
    

    //开 按钮的命令数组
    Command[] onCommands;
    Command[] offCommands;


    //执行撤销的命令
    Command undoCommand;

    public RemoteController() {
    
    
        onCommands = new Command[5];
        offCommands = new Command[5];

        for (int i = 0; i < 5; i++){
    
    
            onCommands[i] = new NoCommand();
            offCommands[i] = new NoCommand();
        }
    }


    //为我们的按钮设置你所需要的命令
    public void setCommand(int no, Command onCommand, Command offCommand){
    
    
        onCommands[no] = onCommand;
        offCommands[no] = offCommand;
    }


    //按下开的按钮
    public void onButtonWasPushed(int no){
    
    
        // 找到你按下的按钮，并调用对应的方法
        onCommands[no].execute();
        //记录这次的操作，用于撤销
        undoCommand = onCommands[no];
    }


    //按下关的按钮
    public void offButtonWasPushed(int no){
    
    
        // 找到你按下的按钮，并调用对应的方法
        offCommands[no].execute();
        //记录这次的操作，用于撤销
        undoCommand = offCommands[no];
    }


    //按下撤销按钮
    public void undoButtonWasPush(){
    
    
        //撤销上次的动作
        undoCommand.undo();
    }

}

cliente cliente

package com.design_patterns.command;

import javafx.scene.effect.Light;

public class Client {
    
    
    public static void main(String[] args) {
    
    
        //使用命令设计模式，完成通过遥控器，对电灯的操作

        /**
         * 创建电灯的对象(接收者)
         */
        LightReceiver lightReceiver = new LightReceiver();

        //创建电灯相关的开关命令
        LightOnCommand lightOnCommand = new LightOnCommand(lightReceiver);
        LightOffCommand lightOffCommand = new LightOffCommand(lightReceiver);


        //创建一个遥控器
        RemoteController remoteController = new RemoteController();

        //给我们的遥控器设置相关的命令，比如 no = 0 使电灯的开和关的操作
        remoteController.setCommand(0,lightOnCommand,lightOffCommand);


        System.out.println("----按下灯的开的按钮----");
        remoteController.onButtonWasPushed(0);
        System.out.println("----按下灯的关的按钮----");
        remoteController.offButtonWasPushed(0);

        System.out.println("----撤销的操作----");
        remoteController.undoButtonWasPush();


        /**
         * 创建电视TV的对象(接收者)
         */
        TVReceiver tvReceiver = new TVReceiver();

        //创建电视TV相关的开关命令
        TVOnCommand tvOnCommand = new TVOnCommand(tvReceiver);
        TVOffCommand tvOffCommand = new TVOffCommand(tvReceiver);

        //给我们的遥控器设置相关的命令，比如 no = 1 使用电视TV的开和关的操作
        remoteController.setCommand(1,tvOnCommand,tvOffCommand);


        System.out.println("----按下电视TV的开的按钮----");
        remoteController.onButtonWasPushed(1);
        System.out.println("----按下电视TV的关的按钮----");
        remoteController.offButtonWasPushed(1);

        System.out.println("----撤销的操作----");
        remoteController.undoButtonWasPush();

    }
}

resultado de la operación

----按下灯的开的按钮----
电灯打开了!
----按下灯的关的按钮----
电灯关闭了!
----撤销的操作----
电灯打开了!
----按下电视TV的开的按钮----
电视TV打开了！
----按下电视TV的关的按钮----
电视TV关闭了！
----撤销的操作----
电视TV打开了！

Resumir

La función principal del modo de comando es realizar la separación del extremo solicitante y el extremo de ejecución . Se utiliza un objeto de solicitud para recibir la solicitud, y se llama al extremo de ejecución para realizar la operación. El mismo modo de comando también realiza la acción de deshacer funcionamiento de la acción , lo que mejora aún más la solidez del programa.

Bueno, este es el modo de comando. Si no lo entiende, por favor deje un comentario a continuación~