Command pattern sa iyong sariling mga salita

Kumusta sa lahat, mga miyembro ng forum!

Naisip ko nang lubusan (parang sa akin) ang pattern Commandat gusto kong subukang pag-usapan ito "sa sarili kong mga salita." Batay sa Wikipedia, malalaman natin na ang layunin nito ay lumikha ng isang istraktura kung saan ang klase ng pagpapadala at ang tumatanggap na klase ay hindi direktang umaasa sa isa't isa. Pag-aayos ng callback sa isang klase na kinabibilangan ng klase ng nagpadala . Sa prinsipyo, ito ay nakasulat nang malinaw at tama, ngunit ito ay nasa teorya. Paano ito gawin? Dito nagsisimula ang mga problema, dahil... ang paglalarawan ay hindi na masyadong malinaw at halata. Samakatuwid, naisip ko ito, nagpasya akong sabihin sa iyo kung paano ko ito naunawaan, marahil ito ay magiging kapaki-pakinabang sa isang tao: Batay sa paglalarawan ng layunin ng pattern na ito, isasama ko ang paglalarawan sa code upang gawing mas malinaw, kasi sa parehong Wikipedia ay ini-generalize nila ito para sa maraming wika at samakatuwid ang paglalarawan ay hiwalay sa halimbawa. Mayroong apat na termino sa pattern na ito, tanggapin natin ang mga ito para sa ngayon: commands( command), command receiver( receiver), command caller( invoker) at client( client). Kukuha ako ng isang halimbawa mula sa parehong Wikipedia, ito ay medyo matitiis. Ang gawain ay isang klase Lightna maaaring gumawa ng dalawang bagay: buksan ang ilaw at patayin ito. Sa mga tuntunin ng pattern ito ay magiging "command receiver ( 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");
     }
}

Gumawa tayo ng isang interface na may isang paraan execute()na ipapatupad at tinatawag sa mga tuntunin ng pattern na "command ( command)"

/*the Command interface*/

public interface Command{
    void execute();
}

Ito ay kinakailangan upang i-encapsulate ang pagpapatupad ng mga kasanayan sa klase Light. Upang gawin ito, gagawa kami ng mga klase TurnOnLightCommandat TurnOffLightCommandmagpapatupad ng interface Commandat kung saan ay tatanggap ng object ng klase sa constructor Light. At ang bawat isa sa kanila ay gagawa lamang ng isang aksyon. Ang isa ay tatawag sa pamamaraan turnOn(), at ang isa ay tatawag 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();
   }
}

Ngayon ay oras na upang lumikha ng isang bagay na tumatanggap ng mga naka-encapsulated object na pamamaraan na ito Light. Sa mga tuntunin ng pattern, ito ay tinatawag na command caller (invoker). Tawagan natin ito Switchat hayaan itong tanggapin ang mga variable sa constructor Commandna gagamitin sa mga ginawang pamamaraan flipUp()at 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();
    }
}

At siyempre, gagawa kami ng klase na gagamitin ang mga ito para maunawaan kung ano ang nangyayari sa pangkalahatan. Ito ay tatawaging pangunahing pamamaraan, kung saan ang lahat ng aksyon ay magaganap:

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

Ang magiging output ay ang mga sumusunod:

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

Saan ito inilalapat?

Ang layunin ay malinaw kung ano at bakit ito kinakailangan, lalo na: sa isang sitwasyon kung saan kailangan mong paghiwalayin ang isang tiyak na pagpapatupad, ito ay napaka-maginhawa. Upang ang paggamit ng ilang mga pag-andar ay hindi nakasalalay sa isang tiyak na pagpapatupad at maaari itong mabago nang hindi napinsala ang system. ganito...) Isulat mo ang iyong mga komento, pag-usapan natin, baka may gawing mas simple at masabihan ng mas mahusay, i-edit natin ang lahat kung kinakailangan) Para sa mga unang magbabasa, ito ay malinaw hangga't maaari. Well, kung sino ang magustuhan ng artikulo ay naglalagay ng "+" dito :) Mahalaga ito para sa akin) Sa paglipas ng panahon, gusto kong magsulat ng higit pa tungkol sa Builder, Singletonat iba pa. Tingnan din ang aking iba pang mga artikulo:

• Gawain sa pagsubok: "Sumulat ng Interpreter sa wikang BrainFuck"

• Pagsubok na gawain "Paghahambing ng Larawan"

• Java - mas mabilis, mas malakas at mas mataas! Mga suweldo ng mga Ukrainian programmer

• Kwento ng tagumpay 1.5 taon pagkatapos ng pagsisimula ng pagsasanay

• Mga teknikal na tanong sa panahon ng isang panayam

• Paano makahanap ng trabaho? Nagpapadala ng mga resume

• Propesyonal na pagkasunog. Paano lumaban?

• English para sa IT at para sa mga panayam

• Paano gumawa ng executable jar sa Intellij IDEA / paano gumawa ng jar sa IDEA

• Singleton pattern sa sarili mong salita

• Tulong, kailangan ko ng motibasyon!