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.
WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 ProbetestsEin zu beobachtendes Objekt muss zwei Grundregeln einhalten:
Vor update() muss das beobachtete Objekt sowohl die Methoden setChanged() als auch notifyObservers() aufrufen.
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:
Im Folgenden sind die Methoden der Observable-Klasse aufgeführt:
Innerhalb eines Programms nimmt die Interaktion zwischen einem Beobachtbaren und einem Beobachter normalerweise die Form der folgenden Abfolge von Ereignissen an.
Im Folgenden finden Sie Beispiele für Observable in Java:
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 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.
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!
