Le modèle d'observateur, également appelé modèle de publication-abonnement, est une relation un-à-plusieurs entre des objets Lorsque l'état d'un objet change, tous les objets qui en dépendent sont notifiés et automatiquement mis à jour.
Rôle de thème abstrait (Sujet
Subject
)
也叫抽象目标类,抽象主题知道自己的观察者有哪些,提供删除和新增观察者的方法以及通知观察者的抽象方法,由抽象类或接口实现
抽象观察者角色(Observer
)
包含了一个更新的抽象方法,当收到具体主题的更新通知后调用,由抽象类或接口实现
具体主题角色(Concrete Subject
)
也叫具体目标类,实现抽象目标类的通知方法,当具体主题发生改变时通知所有订阅自己的观察者
具体观察者角色(Concrete Observer
)
实现抽象观察者角色的抽象方法,收到主题更改通知后更改自身状态
抽象观察者Observer
接口
包含一个观察者接收通知改变自身状态方法
public interface Observer { //收到通知,改变自身状态 void update(); }
具体观察者ObserverOne
和ObserverTwo
实现Observer接口中的update方法
public class ObserverOne implements Observer{ @Override public void update() { System.out.println("第一个观察者收到通知,状态更新了"); } }
public class ObserverTwo implements Observer { @Override public void update() { System.out.println("第二个观察者收到通知,状态更新了"); } }
Subject
接口
包含添加,删除,通知观察者方法,由抽象目标类实现,还有一个自身操作的方法,由具体目标类实现
public interface Subject { //添加观察者 void add(Observer observer); //删除观察者 void remove(Observer observer); //通知所有观察者 void notifyObservers(); //自身操作 void operation(); }
抽象目标类AbstractSubject
抽象类,因为观察者数量不固定,所以使用Vector动态数组存储观察者,实现Subject接口中的add,remove,notifyObservers方法,operation方法由具体目标类实现
public abstract class AbstractSubject implements Subject{ Vector<Observer> vector = new Vector<Observer>(); @Override public void add(Observer observer){ vector.add(observer); } @Override public void remove(Observer observer){ vector.remove(observer); } @Override public void notifyObservers(){ for (Observer observer : vector) { observer.update(); } } }
具体目标类MySubject
继承AbstractSubject类,实现operation方法,并在operation方法中调用notifyObservers方法以达到自身状态改变后通知观察者的效果
public class MySubject extends AbstractSubject{ @Override public void operation() { System.out.println("具体目标状态改变"); System.out.println("正在通知观察者。。。"); notifyObservers(); System.out.println("通知完毕!"); } }
测试类Test
)
également appelé classe cible abstraite, le thème abstrait sait quels observateurs il a et fournit
méthodes pour supprimer et ajouter des observateurs. méthode abstraiteLe rôle d'observateur abstrait (Observateur
contient une méthode abstraite mise à jour lorsqu'elle est reçue Appelée après la mise à jour notification d'un sujet spécifique, implémentée par une classe ou une interface abstraite classe cible, avertit tous les observateurs qui s'abonnent à eux-mêmes lorsque
Le sujet spécifique changeRôle d'observateur concret (Observateur concret
Méthode abstraite pour implémenter le rôle d'observateur abstrait, reçu Changer son propre statut après la notification de changement de thème
implementation
Observer
contient une méthode d'observateur pour recevoir des notifications et modifier son statut
public class Test { public static void main(String[] args) { MySubject mySubject = new MySubject(); mySubject.add(new ObserverOne()); mySubject.add(new ObserverTwo()); mySubject.operation(); } }
ObserverOne
et ObserverTwo code >
Subject
contient des méthodes pour ajouter, supprimer et notifier des observateurs, implémentées par la classe cible abstraite, et une méthode pour sa propre opération, implémentée par la classe cible spécifique
rrreeeAbstractSubject
MySubject
🎜🎜Héritez la classe AbstractSubject, implémentez l'opération méthode, et 🎜appelez la méthode notifyObservers dans la méthode d'opération 🎜Pour obtenir l'effet de notifier les observateurs après leurs propres changements de statut🎜rrreee🎜🎜Classe de test🎜Test
🎜rrreee🎜🎜🎜🎜Résumé 🎜🎜🎜 Quels problèmes le modèle d'observateur résout-il principalement ?? changements, tous les objets dépendants recevront des notifications de diffusion🎜🎜🎜Observateurs Avantages du modèle🎜🎜🎜L'observateur et la cible sont couplés abstraitement, un faible couplage et un ensemble de mécanismes de déclenchement🎜🎜🎜Inconvénients du modèle d'observateur🎜🎜🎜🎜 🎜①Si une cible s'appuie sur des observateurs directs et des observateurs indirects. S'il y en a beaucoup, il faudra beaucoup de temps pour notifier tous les observateurs🎜🎜🎜🎜② S'il existe des dépendances circulaires entre l'observateur et l'observé, des appels circulaires peuvent se produire, provoquant le système plante🎜🎜🎜🎜③L'observateur ne peut pas connaître la cible Comment l'état change, vous pouvez seulement savoir que l'état cible a changé🎜🎜🎜🎜🎜Notes sur le modèle d'observateur🎜🎜🎜🎜🎜①Il existe déjà une classe de support pour le modèle d'observateur en JAVA, vous pouvez l'utiliser directement🎜🎜🎜🎜② Évitez les appels circulaires 🎜🎜🎜🎜③ Si les méthodes de mise à jour des observateurs sont exécutées séquentiellement, une erreur d'observateur entraînera le blocage du système Généralement, un asynchrone. méthode est utilisée. 🎜🎜🎜Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!