Share
Acum, aici vin un model de design mai comportamental din această serie, care este modelul de observator. Observatorul înseamnă că cineva se uită la activitatea dvs. și este posibil ca observatorul să întreprindă anumite acțiuni în funcție de activitatea dvs..
Același concept este aplicabil și modelului de design. Ar trebui să implementăm acest model atunci când avem o dependență unu-la-multe dintre obiectul nostru și un obiect trebuie schimbat / notificat când se fac modificări oricărui alt obiect.
Wikipedia spune același lucru în cuvintele de mai jos:
Modelul de observator este un model de design software în care un obiect numit subiect păstrează o listă a dependenților săi, numiți observatori, și îi notifică automat despre orice schimbări de stare, de obicei apelând una dintre metodele lor. Acesta este folosit în principal pentru implementarea sistemelor distribuite de gestionare a evenimentelor. Modelul Observer este, de asemenea, o parte esențială în modelul arhitectural familiar model-view-controller (MVC).
Pentru a elabora mai multe despre acest model de design, iau exemplul unui simulator care arată valoarea diferitelor valute față de dolarul american. Presupunem că simulatorul arată prețul și actualizează, de asemenea, prețul la intervale regulate.
Înainte de a începe, să definim responsabilitățile clasei principale de simulatoare (care se comportă ca observator în acest exemplu).
În următoarea secțiune, vom implementa observatorul nostru:
interfață Observer funcția publică addCurrency (Valută $ currency); priceSimulator de clasă implementează Observer valute private $; funcția publică __construct () $ this-> valrencies = array (); funcția publică addCurrency (valută $ valută) array_push ($ this-> valute, $ currency); funcția publică actualizarePrice () foreach ($ this-> valute ca $ valută) $ currency-> update ();
Dacă vă uitați la codul de mai sus, puteți vedea că are capacitatea de a îndeplini toate responsabilitățile pe care le-am menționat în secțiunea anterioară.
Acum avem pregătiți observatorul nostru. Acum avem nevoie de câteva valute diferite pe care le putem adăuga acestui observator și apoi suntem bine să mergem. Să implementăm cursurile noastre de valută acum.
interfață Valută update public function (); funcția publică getPrice (); clasa Pound implementează moneda privat $ price; funcția publică __construct ($ price) $ this-> price = $ price; ecou "Pound Prețul original: $ price
"; actualizare funcția publică () $ this-> price = $ this-> getPrice (); echo"Pound Preț actualizat: $ this-> price
"; funcția publică getPrice () return f_rand (0.65, 0.71); clasa Yen implementează valuta privat $ price; funcția publică __construct ($ price) $ this-> price = $ price;Yen Preț inițial: $ price
"; actualizare funcția publică () $ this-> price = $ this-> getPrice (); echo"Yen Preț actualizat: $ this-> price
"; funcția publică getPrice () return f_rand (120.52, 122.50);
Suntem acum pregătiți să punem totul împreună și să ne conducem observatorul.
interfață Observer funcția publică addCurrency (Valută $ currency); priceSimulator de clasă implementează Observer valute private $; funcția publică __construct () $ this-> valrencies = array (); funcția publică addCurrency (valută $ valută) array_push ($ this-> valute, $ currency); funcția publică actualizarePrice () foreach ($ this-> valute ca $ valută) $ currency-> update (); interfață Valută public function update (); funcția publică getPrice (); clasa Pound implementează moneda privat $ price; funcția publică __construct ($ price) $ this-> price = $ price; ecou "Pound Prețul original: $ price
"; actualizare funcția publică () $ this-> price = $ this-> getPrice (); echo"Pound Preț actualizat: $ this-> price
"; funcția publică getPrice () return f_rand (0.65, 0.71); clasa Yen implementează valuta privat $ price; funcția publică __construct ($ price) $ this-> price = $ price;Yen Preț inițial: $ price
"; actualizare funcția publică () $ this-> price = $ this-> getPrice (); echo"Yen Preț actualizat: $ this-> price
"; funcția publică getPrice () return f_rand (120.52, 122.50); funcția f_rand ($ min = 0, $ max = 1, $ mul = 1000000) if ($ min> $ max) return false; mt_rand ($ min * $ mul, $ max * $ mul) / $ mul; $ priceSimulator = un nou prețSimulator (); $ currency1 = o nouă lună (0.60); ($ valută1); $ priceSimulator-> addCurrency ($ currency2); echo "
"$ priceSimulator-> updatePrice (); echo"
"; $ priceSimulator-> updatePrice ();
Codul de mai sus va afișa:
Pound Pret original: 0.6 Yen Original Pret: 122 ------------- Pound Actualizat în Pret: 0.65346 Yen Actualizat în preț: 121.287809 ------------- Pound Actualizat în: 0.671269 Yen Prețul actual: 121.300605
Aici puteți vedea că am actualizat prețurile pentru toate monedele înregistrate și sunt afișate în simulatorul nostru. Acum vom lua în considerare modul în care putem adăuga noi valute la acest simulator cu doar o modificare minoră.
Această modificare include înregistrarea monedelor numai la simulator. Ca atare, codul clientului nostru rămâne neatins când se invocă actualizarea prețului în simulatorul nostru.
Adăugarea unei monede noi
Clasa euro implementează moneda privat $ price; funcția publică __construct ($ price) $ this-> price = $ price; ecou "Prețul inițial în euro: $ price
"; actualizare funcția publică () $ this-> price = $ this-> getPrice (); echo"Euro Preț actualizat: $ this-> price
"; funcția publică getPrice () return f_rand (0.78, 0.85);
A fost ușor și simplu să adăugați o nouă monedă. Acum, tot ce trebuie să facem este să înregistrăm această monedă nouă în observatorul nostru și noi toți suntem gata!
$ priceSimulator = preț nouSimulator (); $ valută1 = lire nouă (0,60); $ currency2 = un nou yen (122); $ currency3 = noul Euro (122); $ PriceSimulator-> addCurrency ($ currency1); $ PriceSimulator-> addCurrency ($ currency2); $ PriceSimulator-> addCurrency ($ currency3); ecou "
"$ priceSimulator-> updatePrice (); echo"
"; $ priceSimulator-> updatePrice ();
Starea oricărui obiect este foarte importantă în programarea orientată pe obiecte, deoarece totul se desfășoară între obiecte și interacțiunea dintre ele. Este frecvent cazul în care câteva obiecte trebuie să fie notificate când apar schimbări în alte obiecte. Modelul de proiectare Observer poate fi utilizat atunci când schimbările unui subiect trebuie să fie respectate de unul sau mai mulți observatori.
Nu uitați să lăsați răspunsul dvs. mai jos.
Accentsconagua