Patrón de Diseño Command en Java:

El patrón Command encapsula una solicitud como un objeto, permitiendo la parametrización de los clientes con diferentes solicitudes, encolamiento de solicitudes y lograr la reversión de operaciones.

Ejemplo de Command en Java:

Supongamos que tienes una interfaz Comando que define un método ejecutar():

// Interfaz Comando
interface Comando {
    void ejecutar();
}

Luego, creas implementaciones concretas de Comando, por ejemplo, ComandoEncender y ComandoApagar:

// ComandoEncender
class ComandoEncender implements Comando {
    private Dispositivo dispositivo;

    public ComandoEncender(Dispositivo dispositivo) {
        this.dispositivo = dispositivo;
    }

    @Override
    public void ejecutar() {
        dispositivo.encender();
    }
}

// ComandoApagar
class ComandoApagar implements Comando {
    private Dispositivo dispositivo;

    public ComandoApagar(Dispositivo dispositivo) {
        this.dispositivo = dispositivo;
    }

    @Override
    public void ejecutar() {
        dispositivo.apagar();
    }
}

Luego, tienes una clase Dispositivo que tiene métodos encender() y apagar():

// Clase Dispositivo
class Dispositivo {
    public void encender() {
        System.out.println("El dispositivo está encendido");
    }

    public void apagar() {
        System.out.println("El dispositivo está apagado");
    }
}

Ahora, tienes una clase ControlRemoto que actúa como invocador y toma comandos para ejecutarlos:

// Clase ControlRemoto
class ControlRemoto {
    private Comando comando;

    public void setComando(Comando comando) {
        this.comando = comando;
    }

    public void presionarBoton() {
        comando.ejecutar();
    }
}

Ahora puedes usar estos componentes para demostrar el patrón Command:

public class Principal {
    public static void main(String[] args) {
        // Crear un dispositivo
        Dispositivo dispositivo = new Dispositivo();

        // Crear comandos con el dispositivo asociado
        ComandoEncender encender = new ComandoEncender(dispositivo);
        ComandoApagar apagar = new ComandoApagar(dispositivo);

        // Crear un control remoto
        ControlRemoto controlRemoto = new ControlRemoto();

        // Asignar comandos al control remoto
        controlRemoto.setComando(encender);

        // Presionar el botón del control remoto
        controlRemoto.presionarBoton();

        // Cambiar el comando en tiempo de ejecución
        controlRemoto.setComando(apagar);

        // Presionar el botón del control remoto nuevamente
        controlRemoto.presionarBoton();
    }
}

Cuándo usar el patrón Command:

1. Parametrización de Objetos con Operaciones:
   • Cuando necesitas parametrizar objetos con operaciones, retrasar la ejecución de una operación o poner operaciones en una cola.
2. Desacoplamiento entre Emisores y Receptores:
   • Para desacoplar el objeto que emite una solicitud (invocador) del objeto que la realiza (receptor), permitiendo mayor flexibilidad y extensibilidad.
3. Historial y Reversión de Operaciones:
   • Para mantener un historial de operaciones ejecutadas y permitir la reversión de esas operaciones.
4. Implementación de Funcionalidades Tipo Macro:
   • Cuando deseas implementar funcionalidades tipo macro, que involucran varias operaciones encapsuladas en un solo comando.

El patrón Command es particularmente útil cuando necesitas desacoplar la clase que emite una solicitud de la que la realiza, o cuando necesitas soportar operaciones reversibles y mantener un historial de acciones realizadas. Proporciona una manera elegante de encapsular una solicitud como un objeto.