modèle Observateur

Quand il y a beaucoup de relations entre les objets, utiliser le modèle d'observateur (Pattern Observer). Par exemple, quand un objet est modifié, il notifie automatiquement ses objets dépendants. Le modèle d'observateur appartient à des modèles de comportement.

introduction

Intention: définir des dépendances entre les objets de one-to-many, lorsque l'état d'un objet est modifié, tous les objets qui en dépendent sont informés et mis à jour automatiquement.

Principalement pour résoudre: un état de la notification de changement d'objet aux problèmes des autres objets, mais aussi en tenant compte de la facilité d'utilisation et un couplage faible, assurer un haut degré de collaboration.

Quand utiliser: un objet (objet cible) change d' état, tous les objets dépendants (objets observateurs) seront informés, la notification de diffusion.

Comment corriger: la technologie orientée objet l' utilisation, cette dépendance peut être affaiblie.

Le code clé: classe abstraite ont un ArrayList stocké observateurs.

Exemples d'application: 1, lorsque la vente aux enchères, le commissaire - priseur observent le prix le plus élevé, et ensuite informer les autres soumissionnaires offre.2, Journey to the West intérieur Wukong demande la remise Red Boy Bouddha, Bouddha l'eau déversée sur le sol d'une ancienne provoquer de tortue, cette tortue est l'observateur, il a observé que l'action de Bouddha arrosage.

Avantages: 1, l'observateur et l'observé sont abstraites couplé.2, pour établir un mécanisme de déclenchement.

Inconvénients: 1, si l'objet observé a beaucoup d'observateur direct et indirect, il avisera tous les observateurs doivent passer beaucoup de temps.2, s'il y a une dépendance circulaire entre l'observateur et la cible observée, observer la cible se déclencher des appels pour faire circuler entre eux, peut provoquer un crash du système. 3, le mode observateur n'y a aucun mécanisme de laisser le spectateur sait le public est de savoir comment les changements observés, mais il suffit de savoir que la cible change d'observation.

Scénarios d' utilisation:1, méthode commune sous-catégories multiples, et la même logique. 2,, les méthodes complexes importants peuvent être considérés comme une méthode de modèle.

Note: 1, JAVA a déjà des cours de soutien en mode d'observation.2, afin d'éviter des références circulaires. 3, si l'ordre d'exécution, un spectateur peut provoquer des erreurs de système coincés, utilisent généralement le mode asynchrone.

réalisation

Le motif d'observateur en utilisant trois classes Sujet, observateurs et clients. Sous réserve de l'objet client avec l'objet et l'observateur est des méthodes d'observation liées à égalité Client Solutions à partir d'objets. Nous créons laclasse Objet,Observer classe abstraite et d' étendre la classeObserverclasse abstraite de l' entité.

ObserverPatternDemo,nos classes de démonstration en utilisant des objets de classe et les entitésassujettiesà démontrer le modèle Observateur.

Etape 1

Créer la catégorie Objet.

Subject.java

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

public class Sujet {
	
   Liste privée <observateurs> observateurs 
      = New ArrayList <Observer> ();
   Etat int privé;

   public int getState () {
      Etat de retour;
   }

   setState public void (int state) {
      this.state = état;
      notifyAllObservers ();
   }

   public void attach (observateur observateur) {
      observers.add (observateur);		
   }

   notifyAllObservers public void () {
      pour (observateur observateur: observateurs) {
         (Observer.update);
      }
   } 	
}

Etape 2

Créer la classe Observer.

Observer.java

public abstract class Observateur {
   objets protégés Sujet;
   publique mise à jour abstract void ();
}

Etape 3

Créer observateur classe d'entité.

BinaryObserver.java

BinaryObserver public class Observateur {

   publique BinaryObserver (Objet sujet) {
      this.subject = sujet;
      this.subject.attach (this);
   }

   @Override
   update public void () {
      System.out.println ( "String binaire:" 
      + Integer.toBinaryString (subject.getState ())); 
   }
}

OctalObserver.java

OctalObserver public class Observateur {

   publique OctalObserver (Objet sujet) {
      this.subject = sujet;
      this.subject.attach (this);
   }

   @Override
   update public void () {
     System.out.println ( "Octal chaîne:" 
     + Integer.toOctalString (subject.getState ())); 
   }
}

HexaObserver.java

HexaObserver public class Observateur {

   HexaObserver public (sujet Sujet) {
      this.subject = sujet;
      this.subject.attach (this);
   }

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

Etape 4

Utilisez des objets d'entitéSujetet observateurs.

ObserverPatternDemo.java

public class ObserverPatternDemo {
   main (String [] args) {public static void
      subject Sujet = new Sujet ();

      nouvelle HexaObserver (sous réserve);
      nouvelle OctalObserver (sous réserve);
      nouvelle BinaryObserver (sous réserve);

      System.out.println ( "Premier changement d'état: 15");	
      subject.setState (15);
      System.out.println ( "Deuxième changement d'état: 10");	
      subject.setState (10);
   }
}

Etape 5

Vérifiez la sortie.

Premier changement d'état: 15
Hex Chaîne: F
Chaîne Octal: 17
Chaîne binaire: 1111
Deuxième changement d'état: 10
Hex Corde:
Chaîne Octal: 12
Chaîne binaire: 1010