Schema di comando con parole tue

Ciao a tutti, membri del forum!

Ho capito a fondo (mi sembra) lo schema Commande voglio provare a parlarne “con parole mie”. Basandosi su Wikipedia, possiamo scoprire che il suo scopo è creare una struttura in cui la classe mittente e quella ricevente non dipendono direttamente l'una dall'altra. Organizzazione di una richiamata a una classe che include la classe mittente . In linea di principio, è scritto in modo chiaro e corretto, ma questo è in teoria. Come fare questo? È qui che iniziano i problemi, perché... la descrizione non è più così chiara ed evidente. Pertanto, l'ho capito, ho deciso di dirti come l'ho capito, forse sarà utile a qualcuno: in base alla descrizione dello scopo di questo modello, combinerò la descrizione con il codice per renderlo più chiaro, Perché nella stessa Wikipedia lo hanno generalizzato per molte lingue e quindi la descrizione è separata dall'esempio. Ci sono quattro termini in questo schema, diamoli per scontati per ora: comandi( command), ricevitore di comandi( receiver), chiamante di comandi( invoker) e client( client). Prenderò un esempio dalla stessa Wikipedia, è abbastanza tollerabile. Il compito è una classe Lightche può fare due cose: accendere la luce e spegnerla. In termini di modello sarà “ricevitore di comandi ( 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");
     }
}

Creiamo un'interfaccia con un metodo execute()che verrà eseguito e che verrà chiamato in termini del modello "command ( command)"

/*the Command interface*/

public interface Command{
    void execute();
}

È necessario incapsulare l'esecuzione delle abilità di classe Light. Per fare ciò, creeremo delle classi TurnOnLightCommandche TurnOffLightCommandimplementeranno l'interfaccia Commande che accetteranno un oggetto classe nel costruttore Light. E ognuno di loro eseguirà una sola azione. Uno chiamerà il metodo turnOn()e l'altro chiamerà 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();
   }
}

Ora è il momento di creare un oggetto che accetti questi metodi di oggetti incapsulati Light. In termini di pattern, è chiamato chiamante del comando (invoker). Chiamiamolo Switche lasciamo che accetti variabili nel costruttore Commandche verranno utilizzate nei metodi creati 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, naturalmente, creeremo una classe che li utilizzerà per capire cosa sta succedendo in generale. Si chiamerà il metodo principale, in cui si svolgerà tutta l'azione:

/*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();
   }
}

L'output sarà il seguente:

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

Dove viene applicato?

Lo scopo è chiaro cosa e perché è necessario, vale a dire: in una situazione in cui è necessario separare un'esecuzione specifica, questo è molto conveniente. In modo che l'utilizzo di alcune funzioni non dipenda da un'implementazione specifica e possa essere modificato senza danneggiare il sistema. qualcosa del genere...) Scrivete i vostri commenti, discutiamo, magari qualcosa si può semplificare e raccontare meglio, modificheremo tutto se necessario) In modo che per chi legge per la prima volta sia il più chiaro possibile. Bene, a chi piace l'articolo ci mette un "+" :) Questo è importante per me) Col tempo, voglio scrivere di più su Buildere Singletonaltri. Vedi anche gli altri miei articoli:

• Compito del test: "Scrivi un interprete nella lingua BrainFuck"

• Attività di prova "Confronto immagini"

• Java: più veloce, più forte e più alto! Stipendi dei programmatori ucraini

• Storia di successo 1,5 anni dopo l'inizio della formazione

• Domande tecniche durante un colloquio

• Come trovare lavoro? Invio curriculum

• Burnout professionale. Come resistere?

• Inglese per l'informatica e per i colloqui

• Come creare un jar eseguibile in Intellij IDEA / come creare un jar in IDEA

• Modello Singleton con parole tue

• Aiuto, ho bisogno di motivazione!