Beobachtbar in Java

Observable ist eine Klasse in der Programmiersprache Java, mit der Sie Unterklassen erstellen können, die andere Abschnitte des Programms beobachten können. Beobachtende Klassen werden informiert, wenn sich ein Objekt dieser Unterklasse ändert. Wenn ein Beobachter über eine Änderung informiert wird, wird die Methode update() aufgerufen. Die Observable-Klasse ist im Paket java.util verfügbar. Eine Unterklasse der Klasse kann verwendet werden, um ein Objekt zu beschreiben, das die Anwendung beobachten muss. Außerdem kann es einen oder mehrere Beobachter für ein beobachtbares Objekt geben. Die beobachtende Klasse sollte die Observer-Schnittstelle implementieren, die die update()-Methode angibt, die die beobachtenden Klassen implementieren müssen.

Ein zu beobachtendes Objekt muss zwei Grundregeln einhalten:

• Zuerst muss die Methode setChanged() aufgerufen werden, wenn sie geändert wird.
• Es muss die Methode notifyObservers() aufrufen, wenn es bereit ist, Beobachter über das Update zu benachrichtigen. Dadurch wird die update()-Methode in dem/den beobachtenden Objekt(en) aufgerufen.

Vor update() muss das beobachtete Objekt sowohl die Methoden setChanged() als auch notifyObservers() aufrufen.

Syntax von Observable in Java

Deklaration der Observable-Klasse.

Die Deklaration für die Klasse java.util.Observable lautet wie folgt:

public class Observable extends Object

Konstrukteur der beobachtbaren Klasse

Unten ist der Konstruktor der beobachtbaren Klasse angegeben:

• Observable(): Dadurch wird ein Observable erstellt, das keine Beobachter hat.

Methoden der beobachtbaren Klasse

Im Folgenden sind die Methoden der Observable-Klasse aufgeführt:

• void addObserver(Observer o): Diese Methode erstellt einen neuen Beobachter in der Sammlung von Beobachtern für ein solches Objekt, solange es nicht mit einem bereits vorhandenen identisch ist.
• protected void clearChanged(): Diese Methode bedeutet, dass sich dieses Objekt nicht geändert hat oder dass es bereits alle seine Beobachter über die letzte Aktualisierung informiert hat. In diesem Fall gibt die Methode hasChanged() false zurück .
• int countObservers(): Die Anzahl der Beobachter für dieses Observable-Objekt wird von dieser Methode zurückgegeben.
• void deleteObserver(Observer o): Diese Methode entfernt einen Beobachter aus der Beobachterliste dieses Objekts.
• void deleteObservers(): Diese Methode löscht die Beobachterliste und entfernt alle Beobachter aus diesem Objekt.
• boolean hasChanged(): Diese Methode bestimmt, ob dieses Objekt geändert wurde oder nicht.
• void notifyObservers(): Wenn die Methode hasChanged() angibt, dass sich dieses Objekt geändert hat, benachrichtigen Sie alle seine Beobachter und rufen Sie dann die Methode clearChanged() auf, um anzuzeigen, dass es sich nicht geändert hat. An die update()-Methode wird als zweiter Parameter eine Null übergeben.
• void notifyObservers(Object arg): Wenn die Methode hasChanged() angibt, dass sich dieses Objekt geändert hat, benachrichtigen Sie alle seine Beobachter und rufen Sie dann die Methode clearChanged() auf, um anzuzeigen, dass es sich nicht geändert hat. An die update()-Methode wird ein Objekt als zweiter Parameter übergeben.
• protected void setChanged(): Zeigt an, dass dieses Observable-Objekt geändert wurde und die Methode hasChanged() nun true zurückgibt.

Funktionsweise von Observable in Java

Innerhalb eines Programms nimmt die Interaktion zwischen einem Beobachtbaren und einem Beobachter normalerweise die Form der folgenden Abfolge von Ereignissen an.

• Wenn die öffentliche Zugriffsmethode die privaten Daten ändert, ändert sie den internen Status und ruft die setChanged()-Methode auf, um anzuzeigen, dass sich der Status des Modells geändert hat. Dann ruft es notifyObservers() auf, um den Beobachtern mitzuteilen, dass sich etwas geändert hat. Der Aufruf von notifyObservers() kann von überall erfolgen, beispielsweise in der Aktualisierungsschleife eines separaten Threads.
• Als nächstes wird die update()-Methode jedes Beobachters aufgerufen, um anzuzeigen, dass eine Statusaktualisierung stattgefunden hat.

Beispiele für Observable in Java

Im Folgenden finden Sie Beispiele für Observable in Java:

Beispiel #1

Beispiel für Observable in Java zum Durchführen von Änderungen mit oder ohne setChanged()-Methode.

Code:

import java.util.*;
// This is the observer class
class ObserverEx implements Observer
{
public void update(Observable obj, Object arg)
{
System.out.println("Update in an observer side.");
}
}
// This is the obsrvable class
class ObservableEx extends Observable
{
void change_with_setChanged()
{
setChanged();
System.out.println("Change the status with setChanged : " + hasChanged());
notifyObservers();
}
void change_without_setChanged()
{
System.out.println("Change status with setChanged : " + hasChanged());
notifyObservers();
}
}
public class HelloWorld {
public static void main(String args[])
{
ObservableEx Observable = new ObservableEx();
ObserverEx observer1 = new ObserverEx();
ObserverEx observer2 = new ObserverEx();
Observable.addObserver(observer1);
Observable.addObserver(observer2);
Observable.change_with_setChanged();
Observable.change_without_setChanged();
int no = Observable.countObservers();
System.out.println("The number of observers for this Observable are : " + no);
}
}

Ausgabe:

Wie im obigen Programm wird die benutzerdefinierte Observable-Klasse ObservableEx durch Erweitern der Observable-Klasse erstellt, und auch die benutzerdefinierte Observer-Klasse ObserverEx wird durch Implementierung der Observer-Schnittstelle erstellt, wobei die Klasse die Implementierung für das Update bereitgestellt hat( ) Methode. Als nächstes enthält die Klasse ObservableEx zwei Methoden change_with_setChanged() und change_without_setChanged().

The method change_with_setChanged() call the setChanged() and then notify all the observer, which means the changes done here with setChanged will be notified to all the observer.Whereas the method change_without_setChanged() does not call the setChanged() and notify all the observers, which means the changes done here without setChanged will not show to all the observer.

Then, in the main function, one Observable and two Observer objects are created, and also add both the Observer object to this Observable. Next, on Observer objects, the change_with_setChanged() method is called, which notifies both the observers and called the update() method, which prints the message, whereas the change_without_setChanged() method does not call the update() method of the observers. And next finding and printing the number of observers, as we can see in the above output.

Example #2

Example for Observable in Java to perform changes with or without clearChanged() method.

Code:

import java.util.*;
// This is the observer class
class ObserverEx implements Observer
{
public void update(Observable obj, Object arg)
{
System.out.println("Update in an observer side.");
} }
// This is the obsrvable class
class ObservableEx extends Observable
{
void change_with_clearChanged()
{
setChanged();
System.out.println("Removes all the changes made by setChanged method.");
// clearChanged method
clearChanged();
notifyObservers();
}
void change_without_clearChanged()
{
setChanged();
System.out.println("Does not removes all the changes made by setChanged method. ");
notifyObservers();
}
}
public class HelloWorld {
public static void main(String args[])
{
ObservableEx Observable = new ObservableEx();
ObserverEx observer1 = new ObserverEx();
ObserverEx observer2 = new ObserverEx();
Observable.addObserver(observer1);
Observable.addObserver(observer2);
Observable.change_with_clearChanged();
Observable.change_without_clearChanged();
int no = Observable.countObservers();
System.out.println("The number of observers for this Observable are : " + no);
Observable.deleteObserver(observer2);
no = Observable.countObservers();
System.out.println("The number of observers after delete for this Observable are : " + no);
}
}

Output:

As in the above program, the classes ObservableEx and ObserverEx are created. Next, the class ObservableEx contains two methods change_with_clearChanged() and change_without_clearChanged(). The method change_with_clearChanged() call the setChanged(), clearChanged() which removes all the changes made by setChanged method. Whereas the method change_without_clearChanged() does not call the clearChanged() which means the changes made by setChanged method will not remove.

Then, in the main function, one Observable and two Observer objects are created, and also add both the Observer object to this Observable. Next, on Observer objects, the change_with_clearChanged() method is called, which does not call the update() method of the observers, whereas the change_without_setChanged() method calls the update() method of the observers. And next, delete the observer1 and finding reaming Observer and printing, as we can see in the above output.

Conclusion

The Observable class is available in java.util package. An Observable is a class in Java that allows the creation of an Observable subclass that other sections of the program can observe.

Das obige ist der detaillierte Inhalt vonBeobachtbar in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!