Befehlsmuster in Ihren eigenen Worten

Hallo zusammen, Forummitglieder!

Ich habe (wie es mir scheint) das Muster gründlich erkannt Commandund möchte versuchen, „in meinen eigenen Worten“ darüber zu sprechen. Basierend auf Wikipedia können wir herausfinden, dass sein Zweck darin besteht, eine Struktur zu schaffen, in der die sendende Klasse und die empfangende Klasse nicht direkt voneinander abhängig sind. Organisieren eines Rückrufs zu einer Klasse, die die Absenderklasse enthält . Im Prinzip ist es klar und korrekt geschrieben, aber das ist Theorie. Wie macht man das? Hier beginnen die Probleme, denn... Die Beschreibung ist nicht mehr so ​​klar und offensichtlich. Deshalb habe ich es herausgefunden und beschlossen, Ihnen zu sagen, wie ich es verstanden habe. Vielleicht ist es für jemanden nützlich: Basierend auf der Beschreibung des Zwecks dieses Musters werde ich die Beschreibung mit dem Code kombinieren, um es klarer zu machen. Weil In derselben Wikipedia haben sie es für viele Sprachen verallgemeinert und daher ist die Beschreibung vom Beispiel getrennt. Es gibt vier Begriffe in diesem Muster, nehmen wir sie zunächst als selbstverständlich an: commands( command), command Receiver( receiver), command caller( invoker) und client( client). Ich nehme ein Beispiel aus derselben Wikipedia, es ist durchaus erträglich. Bei der Aufgabe handelt es sich um eine Klasse Light, die zwei Dinge tun kann: das Licht ein- und ausschalten. Vom Muster her wird es „Befehlsempfänger ( receiver)“ sein.

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

Lassen Sie uns eine Schnittstelle mit einer Methode erstellen execute(), die ausgeführt wird und die im Sinne des „command( command)“- Musters aufgerufen wird

/*the Command interface*/

public interface Command{
    void execute();
}

Es ist notwendig, die Ausführung von Klassenfähigkeiten zu kapseln Light. Dazu erstellen wir Klassen TurnOnLightCommand, TurnOffLightCommanddie die Schnittstelle implementieren Commandund im Konstruktor ein Klassenobjekt akzeptieren Light. Und jeder von ihnen wird nur eine Aktion ausführen. Einer ruft die Methode auf turnOn(), der andere ruft auf 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();
   }
}

Jetzt ist es an der Zeit, ein Objekt zu erstellen, das diese gekapselten Objektmethoden akzeptiert Light. In Bezug auf das Muster wird es als Befehlsaufrufer (Invoker) bezeichnet. Rufen wir es auf Switchund lassen Sie es Variablen im Konstruktor akzeptieren , die in den erstellten Methoden und Commandverwendet werden . flipUp()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();
    }
}

Und natürlich erstellen wir eine Klasse, die sie nutzt, um zu verstehen, was im Allgemeinen vor sich geht. Es wird die Hauptmethode genannt, in der alle Aktionen stattfinden:

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

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

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

Die Ausgabe wird wie folgt sein:

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

Wo wird das angewendet?

Der Zweck ist klar, was und warum dies erforderlich ist, nämlich: In einer Situation, in der Sie eine bestimmte Ausführung trennen müssen, ist dies sehr praktisch. Damit ist die Nutzung einiger Funktionen nicht von einer bestimmten Implementierung abhängig und kann geändert werden, ohne das System zu beschädigen. So etwas in der Art...) Schreiben Sie Ihre Kommentare, lassen Sie uns diskutieren, vielleicht kann etwas einfacher gemacht und besser erzählt werden, wir werden alles bei Bedarf überarbeiten) Damit es für diejenigen, die es zum ersten Mal lesen, so klar wie möglich ist. BuilderNa ja, wer den Artikel mag, setzt ein „+“ drauf :) Das ist wichtig für mich) Mit der Zeit möchte ich mehr über , Singletonund andere schreiben . Siehe auch meine anderen Artikel:

• Testaufgabe: „Schreiben Sie einen Dolmetscher in der BrainFuck-Sprache“

• Testaufgabe „Bildvergleich“

• Java – schneller, stärker und höher! Gehälter ukrainischer Programmierer

• Erfolgsgeschichte 1,5 Jahre nach Ausbildungsbeginn

• Technische Fragen während eines Vorstellungsgesprächs

• Wie finde ich einen Job? Versenden von Lebensläufen

• Professionelles Burnout. Wie kann man widerstehen?

• Englisch für IT und für Vorstellungsgespräche

• So erstellen Sie eine ausführbare JAR-Datei in Intellij IDEA / So erstellen Sie eine JAR-Datei in IDEA

• Singleton-Muster in Ihren eigenen Worten

• Hilfe, ich brauche Motivation!