A quoi sert le design pattern observer (Observé/Observateur) ?
Concretement ça permet à l’objet Observé d’informer les Observateurs lorsqu’il y a un changement.
Oui mais pourquoi l’utiliser ?
Ca évite de faire de “l’attente active”, du coup pas consommation inutile des ressources pour aller verifier qu’il y a bien eu un changement.
En plus c’est propre et déjâ implémenter en java.
//Fichier ChronoObservable.java
import java.util.Observable;
public class ChronoObservable extends Observable {
private long time;
public ChronoObservable() {
super();
}
//setTime met à jour l'attribut time ensuite il passe en état "Changed" et informe les observateurs avec notifyObservers().
//note : si vous utilisez notifyObservers() sans setChanged() cela n'aura aucun effet.
public void setTime() {
this.time = System.currentTimeMillis();
this.setChanged();
this.notifyObservers();
}
public long getTime() {
return time;
}
}
//Fin de Fichier
//Fichier AfficherChrono.java
import java.util.Observable;
import java.util.Observer;
public class AfficherChrono implements Observer {
//la méthode update est éxécutée lors de la récéption d'une notification d'un objet Observé
public void update(Observable o, Object arg) {
System.out.println("changement du chrono");
}
public static void main(String[] args) {
AfficherChrono Afficher = new AfficherChrono();
ChronoObservable Chrono = new ChronoObservable();
//On ajoute un observateur à la liste des observateurs du ChronoObservable.
Chrono.addObserver(Afficher);
//petite boucle pas trop utile pour montrer que les appels à setTime() éxécutent bien la méthode update de l'observateur.
for (int i=0;i<=100;i++) {
try {
Thread.sleep(200);
} catch (Exception e) {
e.printStackTrace();
}
Chrono.setTime();
}
}
}
//Fin de Fichier
