So implementieren Sie ein Beobachtermuster in JAVA

Konzept

Das Beobachtermuster, auch „Publish-Subscribe-Muster“ genannt, ist eine „Eins-zu-Viele“-Beziehung zwischen Objekten. Wenn sich der Zustand eines Objekts ändert, werden alle davon abhängigen Objekte benachrichtigt und automatisch aktualisiert . Zusammensetzung

Abstrakte Themenrolle (

Subjekt

)

Das abstrakte Thema weiß, welche Beobachter es hat, und bietet 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("通知完毕！");
    }
}

测试类TestMethoden zum Löschen und Hinzufügen von Beobachtern abstrakte Methode

, die den Beobachter benachrichtigt, implementiert durch die abstrakte Klasse oder Schnittstelle

Die Rolle des abstrakten Beobachters (

Observer

)

enthält

eine aktualisierte abstrakte Methode

, wenn sie empfangen wird. Wird nach der Aktualisierung aufgerufen Benachrichtigung über ein bestimmtes Subjekt, implementiert durch eine abstrakte Klasse oder Schnittstelle

Konkrete Subjektrolle (Konkretes Subjekt

)

auch als spezifische Zielklasse bezeichnet, die die Benachrichtigungsmethode des Abstracts implementiert Zielklasse: Benachrichtigen Sie alle Beobachter, die sich selbst abonnieren, wenn Das spezifische Thema sich ändert Ändern Sie den eigenen Status nach der Benachrichtigung über die Änderung des Themas.

Observer

Observer

interface

enthält eine Observer-Methode, um Benachrichtigungen zu empfangen und ihren Status zu ändern

public class Test {
    public static void main(String[] args) {
        MySubject mySubject = new MySubject();
        mySubject.add(new ObserverOne());
        mySubject.add(new ObserverTwo());
        mySubject.operation();
    }
}

• spezifische Beobachter

  ObserverOne
und
• ObserverTwo Code ><p></p>Implementieren Sie die Update-Methode in der Observer-Schnittstelle
rrreeerrreee
• Subject

  Interface

enthält Methoden zum Hinzufügen, Löschen und Benachrichtigen von Beobachtern, implementiert durch die abstrakte Zielklasse, und eine Methode für seine eigene Operation, implementiert durch die spezifische Zielklasse

rrreeeAbstrakte Zielklasse

AbstractSubject
• Abstrakte Klasse, da die Anzahl der Beobachter nicht festgelegt ist, verwenden Sie daher

  Vector Dynamic Array

  zum Speichern von Beobachtern und implementieren Sie die Methode „add“ in der Schnittstelle „Subject“, „remove“ und „notifyObservers“. Die Operationsmethode wird durch die spezifische Zielklasse implementiert Methode und
rufen Sie die notifyObservers-Methode in der Operationsmethode auf
• Um den Effekt zu erzielen, dass Beobachter nach ihren eigenen Statusänderungen benachrichtigt werden

  rrreee

Testklasse
• Test

  rrreee

🎜Zusammenfassung 🎜🎜🎜 Welche Probleme löst das Beobachtermuster hauptsächlich🎜🎜🎜bei niedrigen Bedingungen? Wenn sich unter der Bedingung der Kopplung der Zustand eines Objekts ändert, erhalten andere Objekte Benachrichtigungen🎜🎜🎜Wann das Beobachtermuster verwendet werden soll🎜🎜🎜Wenn sich der Zustand eines Objekts ändert Bei Änderungen erhalten alle abhängigen Objekte Broadcast-Benachrichtigungen🎜🎜🎜Beobachter Vorteile des Musters🎜🎜🎜Der Beobachter und das Ziel sind abstrakt gekoppelt, haben eine geringe Kopplung und eine Reihe von Auslösemechanismen🎜🎜🎜Nachteile des Beobachtermusters🎜🎜🎜🎜 🎜①Wenn ein Ziel auf direkte Beobachter und indirekte Beobachter angewiesen ist Wenn es viele gibt, wird es viel Zeit in Anspruch nehmen, alle Beobachter zu benachrichtigen🎜🎜🎜🎜② Wenn zirkuläre Abhängigkeiten zwischen dem Beobachter und dem Beobachteten bestehen, kann es zu zirkulären Aufrufen kommen das System stürzt ab🎜🎜🎜🎜③Der Beobachter kann das Ziel nicht kennen. Wie sich der Zustand ändert, kann man nur wissen, dass sich der Zielzustand geändert hat🎜🎜🎜🎜🎜Hinweise zum Beobachtermuster🎜🎜🎜🎜🎜①Es gibt bereits eine Unterstützungsklasse Für das Beobachtermuster in JAVA können Sie es direkt verwenden Methode verwendet wird. 🎜🎜🎜

Das obige ist der detaillierte Inhalt vonSo implementieren Sie ein Beobachtermuster in JAVA. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!