Observable en Java

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.

Un objet sous observation doit respecter deux règles de base :

• Tout d'abord, il doit appeler la méthode setChanged() si elle est modifiée.
• Il doit appeler la méthode notifyObservers() lorsqu'il est prêt à notifier les observateurs de la mise à jour. La méthode update() dans le ou les objets observateurs est appelée en conséquence.

Avant update(), l'objet observé doit appeler à la fois les méthodes setChanged() et notifyObservers().

Syntaxe d'Observable en Java

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 :

• Observable() : Cela crée un observable qui n'a aucun observateur.

Méthodes de classe observable

Vous trouverez ci-dessous les méthodes de la classe observable :

• void addObserver(Observer o): Cette méthode crée un nouvel observateur dans la collection d'observateurs pour un tel objet, tant qu'il n'est pas le même que celui qui existe déjà.
• protected void clearChanged() : Cette méthode signifie que cet objet n'a pas changé ou qu'il a déjà informé tous ses observateurs de la mise à jour la plus récente, auquel cas la méthode hasChanged() renvoie false .
• int countObservers() : Le nombre d'observateurs pour cet objet Observable est renvoyé par cette méthode.
• void deleteObserver(Observer o): Cette méthode supprime un observateur de la liste des observateurs de cet objet.
• void deleteObservers() : Cette méthode efface la liste des observateurs, supprimant tous les observateurs de cet objet.
• boolean hasChanged() : Cette méthode détermine si cet objet a été modifié ou non.
• void notifyObservers() : Si la méthode hasChanged() indique que cet objet a changé, alertez tous ses observateurs puis appelez la méthode clearChanged() pour montrer qu'il n'a pas changé. Pour la méthode update(), une valeur null est passée comme deuxième paramètre.
• void notifyObservers(Object arg): Si la méthode hasChanged() indique que cet objet a changé, alertez tous ses observateurs puis appelez la méthode clearChanged() pour montrer qu'il n'a pas changé. À la méthode update(), un objet est passé comme deuxième paramètre.
• protected void setChanged() : Il indique que cet objet observable a été modifié et la méthode hasChanged() retournera désormais true.

Fonctionnement d'Observable en Java

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.

• Lorsque la méthode d'accès public modifie les données privées, change l'état interne et appelle la méthode setChanged() pour montrer que l'état du modèle a changé. Ensuite, il appelle notifyObservers() pour informer les observateurs que quelque chose a changé. L’appel à notifyObservers() peut être effectué depuis n’importe où, par exemple dans la boucle de mise à jour d’un thread séparé.
• Ensuite, la méthode update() de chaque observateur est appelée, indiquant qu'une mise à jour de l'état a eu lieu.

Exemples d'observables en Java

Vous trouverez ci-dessous les exemples d'Observable en Java :

Exemple n°1

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 #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.

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!