Padrão de comando com suas próprias palavras

Olá a todos, membros do Fórum!

Eu descobri completamente (me parece) o padrão Commande quero tentar falar sobre ele “com minhas próprias palavras”. Com base na Wikipedia, podemos descobrir que seu objetivo é criar uma estrutura na qual a classe emissora e a classe receptora não dependam diretamente uma da outra. Organizando um retorno de chamada para uma classe que inclui a classe remetente . Em princípio, está escrito de forma clara e correta, mas isso é em teoria. Como fazer isso? É aqui que começam os problemas, porque... a descrição não é mais tão clara e óbvia. Portanto, descobri, resolvi contar como entendi, talvez seja útil para alguém: Com base na descrição da finalidade deste padrão, combinarei a descrição com o código para torná-lo mais claro, porque na mesma Wikipedia eles generalizaram para vários idiomas e portanto a descrição é separada do exemplo. Existem quatro termos neste padrão, vamos tomá-los como garantidos por enquanto: comandos( command), receptor de comando( receiver), chamador de comando( invoker) e cliente( client). Vou pegar um exemplo da mesma Wikipedia, é bastante tolerável. A tarefa é uma classe Lightque pode fazer duas coisas: acender a luz e apagá-la. Em termos do padrão será “receptor de comando ( receiver)”

/*Receiver class*/

public class Light{
     public Light(){  }

     public void turnOn(){
        System.out.println("The light is on");
     }

     public void turnOff(){
        System.out.println("The light is off");
     }
}

Vamos criar uma interface com um método execute()que será executado e que é chamado em termos do padrão "command( command)"

/*the Command interface*/

public interface Command{
    void execute();
}

É necessário encapsular a execução das habilidades da classe Light. Para isso, criaremos classes TurnOnLightCommande TurnOffLightCommandque implementem a interface Commande que aceitarão um objeto de classe no construtor Light. E cada um deles realizará apenas uma ação. Um chamará o método turnOn()e o outro chamará turnOff().

/*the Command for turning on the light*/

public class TurnOnLightCommand implements Command{
   private Light theLight;

   public TurnOnLightCommand(Light light){
        this.theLight=light;
       }

   public void execute(){
      theLight.turnOn();
   }
}

/*the Command for turning off the light*/

public class TurnOffLightCommand implements Command{
   private Light theLight;

   public TurnOffLightCommand(Light light){
        this.theLight=light;
       }

   public void execute(){
      theLight.turnOff();
   }
}

Agora é hora de criar um objeto que aceite esses métodos de objeto encapsulados Light. Em termos de padrão, ele é chamado de chamador de comando (invocador). Vamos chamá-lo Switche deixá-lo aceitar variáveis ​​no construtor Commandque serão utilizadas nos métodos criados flipUp()e flipDown().

/*the Invoker class*/

public class Switch {
    private Command flipUpCommand;
    private Command flipDownCommand;

    public Switch(Command flipUpCommand,Command flipDownCommand){
         this.flipUpCommand=flipUpCommand;
         this.flipDownCommand=flipDownCommand;
    }

    public void flipUp(){
         flipUpCommand.execute();
    }

    public void flipDown(){
         flipDownCommand.execute();
    }
}

E claro, criaremos uma classe que irá utilizá-los para entender o que está acontecendo em geral. Será chamado de método principal, no qual ocorrerá toda a ação:

/*The test class*/
public class TestCommand{
   public static void main(String[] args){
       // создаем an object, который будет использоваться
       Light l=new Light();
       // создаем an objectы для всех умений an object Light:
       Command switchUp=new TurnOnLightCommand(l);
       Command switchDown=new TurnOffLightCommand(l);

       // Создаемтся invoker, с которым мы будем непосредственно контактировать:
       Switch s=new Switch(switchUp,switchDown);

       // вот проверка этого, используем методы:
       s.flipUp();
       s.flipDown();
   }
}

A saída será a seguinte:

"The light is on"
"The light is off"

Onde isso é aplicado?

O objetivo é claro o que e por que isso é necessário, a saber: numa situação em que é necessário separar uma execução específica, isso é muito conveniente. Para que a utilização de algumas funções não dependa de uma implementação específica e possa ser alterada sem danificar o sistema. algo assim...) Escreva seus comentários, vamos discutir, talvez algo possa ser simplificado e contado melhor, editaremos tudo se necessário) Para que para quem vai ler pela primeira vez fique o mais claro possível. Bom, quem gosta do artigo coloca um “+” nele :) Isso é importante para mim) Com o tempo, quero escrever mais sobre Builder, Singletone outros. Veja também meus outros artigos:

• Tarefa de teste: "Escreva um intérprete na linguagem BrainFuck"

• Tarefa de teste "Comparação de imagens"

• Java - mais rápido, mais forte e mais avançado! Salários dos programadores ucranianos

• História de sucesso 1,5 anos após o início do treinamento

• Perguntas técnicas durante uma entrevista

• Como encontrar um emprego? Envio de currículos

• Esgotamento profissional. Como resistir?

• Inglês para TI e para entrevistas

• Como criar um jar executável no Intellij IDEA / como criar um jar no IDEA

• Padrão Singleton com suas próprias palavras

• Socorro, preciso de motivação!