Comment implémenter un modèle d'observateur en JAVA

Concept

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.

Composition

Rôle de thème abstrait (SujetSubject）

也叫抽象目标类，抽象主题知道自己的观察者有哪些，提供删除和新增观察者的方法以及通知观察者的抽象方法，由抽象类或接口实现

抽象观察者角色（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 abstraite

qui notifie l'observateur, implémentée par la classe abstraite ou l'interface

Le 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 change

Rô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

• abstract observer

  Observer

  interface

• 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();
      }
  }

  observateurs spécifiques

  ObserverOne et ObserverTwo code >

  Implémentez la méthode de mise à jour dans l'interface Observer
  • rrreeerrreee

    Subject

    Interface

  • 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

    rrreee
  • Classe cible abstraite

    AbstractSubject

  Classe abstraite, car le nombre d'observateurs n'est pas fixe, utilisez donc
  Tableau dynamique vectoriel🎜 pour stocker les observateurs et implémentez l'ajout dans l'interface Sujet, la suppression, la méthode notifyObservers, 🎜la méthode d'opération est implémentée par la classe cible spécifique 🎜🎜rrreee🎜🎜Classe cible spécifique 🎜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!