pattern Observer

Quando ci sono molte relazioni tra gli oggetti, usare il pattern Observer (Observer Pattern). Ad esempio, quando un oggetto viene modificato, notificando automaticamente relativi oggetti dipendenti. Il pattern Observer appartiene a modelli comportamentali.

introduzione

Intento: definire le dipendenze tra gli oggetti di uno-a-molti, quando lo stato di un oggetto viene modificato, tutti gli oggetti che dipendono da esso vengono notificati e aggiornati automaticamente.

Principalmente per risolvere: uno stato della notifica di cambiamento dell'oggetto ai problemi di altri oggetti, ma anche tenendo conto della facilità d'uso e accoppiamento basso, garantire un elevato grado di collaborazione.

Quando utilizzare: un oggetto (oggetto di destinazione) cambia stato, tutti gli oggetti dipendenti (oggetti osservatore) saranno informati, la notifica in onda.

Come risolvere: la tecnologia object-oriented uso, questa dipendenza può essere indebolita.

Il codice chiave: classe astratta hanno un ArrayList memorizzati osservatori.

Esempi di applicazione: 1, quando l'asta, il banditore osservare il prezzo più alto, e quindi notificare altri offerenti offerta.2, Viaggio in Occidente all'interno Wukong richiesta di riscatto Red Boy Buddha, il Buddha acqua versata sul pavimento di una vecchia tartaruga provocano, questa tartaruga è l'osservatore, ha osservato che l'azione Buddha irrigazione.

Vantaggi: 1, l'osservatore e l'osservato sono astratti accoppiato.2, di stabilire un meccanismo di innesco.

Svantaggi: 1, se l'oggetto osservato ha un sacco di osservatore diretto e indiretto, ne informa tutti gli osservatori sono a spendere un sacco di tempo.2, se vi è una dipendenza circolare tra l'osservatore e l'osservato bersaglio, osservare il bersaglio farà scattare le chiamate a circolare tra di loro, può causare il crash di sistema. 3, la modalità osservatore non esiste alcun meccanismo per far conoscere allo spettatore il pubblico è come le variazioni osservate, ma è sufficiente sapere che i cambiamenti di destinazione di osservazione.

scenari di utilizzo: 1, più sottoclasse metodo comune, e la stessa logica.2, importanti, metodi complessi può essere considerato come un metodo template.

Nota: 1, Java ha già osservatori classi di supporto modalità.2, per evitare riferimenti circolari. 3, se l'ordine di esecuzione, un visualizzatore può causare errori di sistema bloccato, in genere utilizzare la modalità asincrona.

realizzazione

Il pattern Observer utilizzando tre classi Soggetto, Observer e Client. Soggetto all'oggetto client con l'oggetto e l'osservatore è metodi osservatori bound legate Client Solutions da oggetti. Creiamo laclasse Soggetto,Observer classe astratta ed estendere la classe di entità astratta classeObserver.

ObserverPatternDemo,i nostri corsi dimostrativi utilizzando oggetti di classe ed entitàsoggettea dimostrare il pattern Observer.

fase 1

Crea Soggetto categoria.

Subject.java

import java.util.ArrayList;
import java.util.List;

public class Soggetto {
	
   Elenco privato <Observer> osservatori 
      = New ArrayList <Observer> ();
   int stato privato;

   public int getState () {
      stato tornare;
   }

   setState public void (int stato) {
      this.state = Stato;
      notifyAllObservers ();
   }

   public void allegare (Observer osservatore) {
      observers.add (osservatore);		
   }

   notifyAllObservers public void () {
      per (Observer osservatore: osservatori) {
         observer.update ();
      }
   } 	
}

fase 2

Crea classe Observer.

Observer.java

classe astratta pubblica Observer {
   protetta soggetto Soggetto;
   pubblica aggiornamento vuoto astratto ();
}

fase 3

Creare osservatore classe di entità.

BinaryObserver.java

public class BinaryObserver estende Observer {

   pubblico BinaryObserver (Salvo soggetto) {
      this.subject = soggetto;
      this.subject.attach (questo);
   }

   @Override
   aggiornamento public void () {
      System.out.println ( "stringa binaria:" 
      + Integer.toBinaryString (subject.getState ())); 
   }
}

OctalObserver.java

public class OctalObserver estende Observer {

   pubblico OctalObserver (Salvo soggetto) {
      this.subject = soggetto;
      this.subject.attach (questo);
   }

   @Override
   aggiornamento public void () {
     System.out.println ( "ottale String:" 
     + Integer.toOctalString (subject.getState ())); 
   }
}

HexaObserver.java

public class HexaObserver estende Observer {

   HexaObserver pubblico (Salvo soggetto) {
      this.subject = soggetto;
      this.subject.attach (questo);
   }

   @Override
   aggiornamento public void () {
      System.out.println ( "Hex String:" 
      + Integer.toHexString (subject.getState ()) .toUpperCase ()); 
   }
}

fase 4

Utilizzare oggetti entitàsoggettoe osservatore.

ObserverPatternDemo.java

public class ObserverPatternDemo {
   Main (string [] args) {public static void
      Soggetto subject = nuovo soggetto ();

      nuova HexaObserver (soggetto);
      nuova OctalObserver (soggetto);
      nuova BinaryObserver (soggetto);

      System.out.println ( "cambiamento Prima stato: 15");	
      subject.setState (15);
      System.out.println ( "cambiamento Seconda stato: 10");	
      subject.setState (10);
   }
}

fase 5

Verifica uscita.

Primo cambiamento di stato: 15
Hex String: F
String Octal: 17
Stringa binaria: 1111
Secondo cambiamento di stato: 10
Hex String: A
String Octal: 12
Stringa binaria: 1010