Le mode observateur (parfois appelé mode publication-subscription, mode de vue modèle, mode source-listener ou mode esclave) est un type de mode de conception de logiciel. Dans ce mode, un objet cible gère tous les objets d'observateurs qui en dépendent et émettent activement des notifications lorsque son état change. Ceci est généralement réalisé en appelant les méthodes de chaque observateur. Ce modèle est généralement utilisé pour implémenter des systèmes de traitement d'événements.
Le mode observateur sépare parfaitement l'observateur de l'objet observé. Par exemple, l'interface utilisateur peut être utilisée comme observateur et les données commerciales sont l'observateur. L'interface utilisateur observe les modifications des données de l'entreprise. Après avoir découvert les modifications des données, elles seront affichées sur l'interface. Un principe de conception orientée objet est que chaque classe du système se concentrera sur une fonction, pas d'autres aspects. Une personne ne fait qu'une chose et le fait bien. Le mode observateur établit des limites claires entre les modules, l'amélioration de la maintenabilité et de la réutilisabilité de l'application.
Le modèle de conception de l'observateur définit une dépendance un-à-plusieurs entre les objets de sorte que lorsque l'état d'un objet change, tous les objets qui en dépendent sont notifiés et rafraîchis automatiquement.
Méthode d'implémentation:
Il existe de nombreuses façons de mettre en œuvre le modèle d'observateur, et fondamentalement, le modèle doit contenir deux rôles: l'observateur et l'objet observés. Dans l'exemple tout à l'heure, les données commerciales sont l'objet à observer et l'interface utilisateur est l'observateur. Il existe une relation logique entre l'observateur et l'observateur. Lorsque l'observateur change, l'observateur observera de tels changements et répondra en conséquence. Si un tel processus d'observation est utilisé entre l'interface utilisateur et les données commerciales, il peut être assuré que la frontière entre l'interface et les données est dessinée. En supposant que les besoins de l'application changent, les performances de l'interface doivent être modifiées. Seule une interface utilisateur doit être reconstruite et les données de l'entreprise n'ont pas besoin de changer.
1. Observer
(Observer) s'inscrit dans le sujet, et l'objet observé stocke l'observateur dans un conteneur.
2. Être observé
L'objet observé a un certain changement (comme indiqué dans SomeChange sur la figure), et tous les observateurs enregistrés sont obtenus à partir du conteneur et ont informé l'observateur du changement.
3. Révoquer l'observation
L'observateur dit à l'observateur d'annuler l'observation et supprime l'observateur du conteneur.
Lorsqu'un observateur s'inscrit dans le conteneur de l'observateur, l'observateur ne doit pas poser de questions sur le type spécifique de l'observateur, mais doit utiliser l'interface de l'observateur. Cet avantage est: en supposant qu'il existe d'autres observateurs dans le programme, tant que cet observateur est également implémenté par la même interface. Une personne observée peut correspondre à plusieurs observateurs. Lorsque la personne observée change, il peut informer tous les observateurs un par un. Sur la base des interfaces, et non des implémentations spécifiques - cela offre une plus grande flexibilité pour les programmes.
Code de démonstration:
Définissez la classe abstraite du rôle à observer:
package test.edu.mainrole; import java.util.arraylist; public abstrait class Absrole {private arrayList <ioBserver> list = new ArrayList <IOBServer> (); public void add (iObserver Observer) {list.add (observateur); } public void delete (iObserver Observer) {list.reMove (Observer); } public void nodifyObservers (String NewState) {for (ioBserver Observer: list) {Observer.update (newState); }}} Sous-classe de rôle observé:
package test.edu.mainrole; Le rôle de classe publique étend l'absrole {State de chaîne privée; public String getState () {return State; } public void Change (String Nupdate) {state = nupdate; this.nodifyObservers (état); }} Définissez l'interface de l'observateur:
package test.edu.mainrole; Interface publique iObServer {public void Update (String NewState); } Observateurs spécifiques:
package test.edu.mainrole; public class ObserverObj1 implémente iObserver {private String ObserverState; @Override public void Update (String State) {ObserverState = State; System.out.println ("L'état de l'observateur 1 est:" + ObserverState); }} package test.edu.mainrole; public class ObserverObj2 implémente iObserver {private String ObserverState; @Override public void Update (String State) {ObserverState = State; System.out.println ("L'état de l'observateur 2 est:" + ObserverState); }} Test Client:
package test.edu.mainrole; classe publique Client {/ ** * @param args * / public static void main (string [] args) {role suject = new role (); IObServer Observer1 = new ObserverObj1 (); IObServer Observer2 = new ObserverObj2 (); sujet.Add (Observer1); sujet.Add (Observer2); sujet.Change ("Update!"); }} Résultats en cours:
L'état de l'observateur 1 est: Mise à jour! L'état de l'observateur 2 est: Mise à jour!
Ce qui précède est tout sur cet article, et j'espère que cela vous inspirera à apprendre.