Observable est une classe du langage de programmation Java qui vous permet de construire des sous-classes que d'autres sections du programme peuvent observer. Les classes observatrices sont informées lorsqu'un objet de cette sous-classe change. Lorsqu'un observateur est informé d'un changement, la méthode update() est appelée. La classe Observable est disponible dans le package java.util. Une sous-classe de la classe peut être utilisée pour décrire un objet que l'application doit observer, et il peut également y avoir un ou plusieurs observateurs sur un objet observable. La classe observatrice doit implémenter l'interface Observer, qui spécifie la méthode update(), que les classes observatrices doivent implémenter.
PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulésUn objet sous observation doit respecter deux règles de base :
Avant update(), l'objet observé doit appeler à la fois les méthodes setChanged() et notifyObservers().
Déclaration de la classe Observable.
La déclaration de la classe java.util.Observable est la suivante :
public class Observable extends Object
Constructeur de classe observable
Vous trouverez ci-dessous le constructeur de la classe observable :
Vous trouverez ci-dessous les méthodes de la classe observable :
Au sein d'un programme, l'interaction entre un observable et un observateur prend généralement la forme de la séquence d'événements suivante.
Vous trouverez ci-dessous les exemples d'Observable en Java :
Exemple d'Observable en Java pour effectuer des modifications avec ou sans la méthode setChanged().
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); } }
Sortie :
Comme dans le programme ci-dessus, la classe définie par l'utilisateur Observable ObservableEx est créée en étendant la classe Observable, et également la classe définie par l'utilisateur Observer ObserverEx est créée en implémentant l'interface Observer où la classe a fourni l'implémentation pour la mise à jour ( ) méthode. Ensuite, la classe ObservableEx contient deux méthodes change_with_setChanged() et 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.
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!