Le mode observateur est l'un des modes de conception logicielle et est également couramment utilisé, en particulier dans la programmation de GUI. Il existe de nombreux articles sur les modèles de conception écrits sur Internet, et de nombreux articles sont bien écrits. Bien qu'il y ait un soupçon de répéter la roue précoce, cette roue n'est pas l'autre roue, avec une concentration différente, différentes idées et différentes façons de le dire.
Éléments clés
thème:
Un sujet est l'objet observé par l'observateur. Un sujet doit avoir les trois caractéristiques suivantes.
Observateur:
Lorsque le sujet change, la réception de notifications pour un traitement spécifique est une fonctionnalité que l'observateur doit avoir.
Pourquoi utiliser ce mode
Voici un exemple pour illustrer que la station de livraison de lait est le thème. Le client d'abonnement au lait est le moniteur. Une fois que le client s'est abonné au lait de la station de livraison de lait, il recevra le lait tous les jours. Si le client ne veut pas s'abonner, il peut annuler et il ne recevra pas de lait à l'avenir.
Couplage lâche
L'observateur ajoute ou supprime le code sans modifier le sujet, appelez simplement la méthode correspondante pour ajouter ou supprimer le sujet.
Le sujet est uniquement responsable de la notification de l'observateur, mais n'a pas besoin de savoir comment l'observateur traite de la notification. Par exemple, la station de livraison de lait n'est responsable que de la livraison du lait et ne se soucie pas de savoir si le client le boit ou se lave le visage.
L'observateur doit simplement attendre la notification du sujet, sans observer les détails liés au sujet. Quant au même exemple, les clients n'ont qu'à se soucier de la station de livraison de lait pour livrer le lait, pas de l'offre de courrier ou du type de transport pour livrer le lait.
Java implémente le mode observateur
1. La propre implémentation de Java
Diagramme de classe
/ ** * La cible d'observation hérite de java.util.observable * @author pierre * * / classe publique UpdateObserable étend observable {private int data; Public UpdateObservable (Observer Observer) {addObserver (Observer); / * * Ajouter un autre observateur * /} public int getData () {return data; } public void setData (int data) {if (data! = this.data) {this.data = data; setChanged (); // change de balise, notifyObservers (); // Notification}} @Override public synchronisé void addObserver (Observer O) {super.addObserver (o); } @Override public synchronisé void DeleteObserver (Observer O) {super.deleteObserver (o); } @Override public void notifyObservers () {super.NotifyObservers (); } @Override public void notifyObservers (objet arg) {super.notifyObservers (arg); } @Override public synchronisé void DeleteObservers () {super.deleteObservers (); } @Override Protected synchronisé void setchanged () {super.Setchanged (); } @Override Protected synchronisé void Clearchanged () {super.Clearchanged (); } @Override public synchronisé boolean haschanged () {return super.haschanged (); } @Override public synchronisé int countoBServers () {return super.countObservers (); }} / ** * Observer implémente Java.util.Observer Interface * @Author Stone * * / public Class UpdateObserver implémente Observer {@Override public void Update (observable o, objet arg) {System.out.println ("Reçu la notification de changement de données:"); if (o instanceof updateObServable) {updateObServable uo = (updateObservable) o; System.out.print ("Données modifiées en:" + uo.getData ()); }}} 2. Modèle d'observation personnalisé
Diagramme de classe
/ ** * Résumé Observer * Mise à jour de l'observation * @Author Stone * * / Interface publique Iwatcher {/ * * Interface de notification: * 1. Notification simple * 2. L'observateur a besoin de données du changement de la cible, afin que la cible puisse être utilisée comme paramètre regardé); void update (); } / ** * Sujet cible abstrait * fournit une interface pour enregistrer et supprimer des objets observateurs, et une interface pour informer les observateurs pour observer * et l'interface à laquelle la cible est observée * @author pierre * * / interface publique iWatchedSubject {public void add (iwatcher watch); public void retire (iwatcher watch); public void notifywhatchers (); public void Update (); // Interface avec les modifications commerciales observées} / ** * Observer spécifique Observer en béton * * @Author Stone * * / public Class UpdateWatcher implémente iWatcher {@Override public void Update () {System.out.println (this + "observé: la cible a été mise à jour"); }} / ** * Rôle cible spécifique Sujet en béton * @author Stone * * / classe publique UpdateWatchEdSubject implémente iWatchedSubject {private list <iwatcher> liste; public updatewatchedSubject () {this.list = new ArrayList <IWatcher> (); } @Override public void add (iwatcher watch) {this.list.add (watch); } @Override public void retira (iwatcher watch) {this.list.remove (watch); } @Override public void notifywhatchers () {for (iwatcher watcher: list) {watcher.update (); }} @Override public void Update () {System.out.println ("Target Update ......"); notifyWHatchers (); }} Un auditeur est une implémentation de l'observateur:
Diagramme de classe
/ ** * Écouteur après s'inscrire * @author Stone * * / interface publique iregisterListener {void onregisterred (); } / ** * Écouteur lorsque l'utilisateur se connecte dans * @author pierre * * / interface publique IloginListener {void OnLogined (); } / * * L'auditeur est une implémentation du mode observateur * Ajouter des auditeurs à certaines interfaces commerciales qui nécessitent l'écoute, appelez les méthodes correspondantes de l'auditeur pour implémenter l'écoute * / classe publique User {public void Register (iregisterListener Register) {/ * * Do ... Register * / System.out.println ("Register ..."); // après le registre d'enregistrement.ongestred (); } public void Login (IloginListener Login) {/ * * do ... Login * / System.out.println ("Enregistrement ..."); // After Login.Onlogined (); }} / ** * Mode comportemental du mode observateur * Le mode observateur définit une dépendance un-à-plusieurs, permettant à plusieurs objets d'observateurs d'observer un objet cible en même temps. * Lorsque cet objet cible change dans son état, il informera tous les objets d'observateurs, afin qu'ils puissent se mettre à jour automatiquement. L'objet cible a besoin d'une interface pour ajouter, supprimer et informer les observateurs * * @author Stone * / public class test {public static void main (String [] args) {/ * * Utiliser l'interface d'observateur de Java (new updateObserver ()); observable.setData (99); System.out.println (""); System.out.println (""); / * * Modèle d'observateur personnalisé * / iWatchedSubject Watted = new updatewatchedSubject (); WatchEd.Add (new UpdateWather ()); WatchEd.Add (new UpdateWather ()); regardé.update (); System.out.println (""); / * * Sous-mode-Listener * / utilisateur utilisateur = new User (); user.register (new iregisterListener () {@Override public void onregisterred () {System.out.println ("après avoir écouté l'enregistrement ...");}}); user.login (new IloginListener () {@Override public void onLogined () {System.out.println ("après avoir écouté Login ...");}}); }}Imprimer
Notification reçue du changement de données: données modifiées en: 99 La cible est mise à jour ... Observer.updatewatcher@457471e0 observé: La cible a été mise à jour observer.updatewatcher@5fe04cbf observée: la cible a été mise à jour et s'inscrit ... après avoir écouté l'enregistrement. . . Connexion ... Après avoir écouté la connexion. . .