Language]Listener sur booléen

existe t il un listener qui permettrais d ecouter et d agir sur le changement d un boolean (par exemple quand il passe de true a false???)

ou purrais t on en construire un ayant cette propriete la ???

[Modéré par Didier] : ajout de tag dans le titre - Les règles du forum Java

Bonjour,

Au moins trois pistes...

(1) La plus simple, et qui correspond probablement à ton besoin : lancer une action depuis le "setter", c'est-à-dire la méthode qui est appelée pour modifier ce booléen.

(2) Le couple Observable/Observer qui permet d'enregistrer plusieurs autres objets comme "observateurs" de celui qui contient le booléen, et de les avertir en cas de changement.

Exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
//par Nicolas_75
import java.util.Observable;
import java.util.Observer;
 
// la classe contenant le champ à surveiller
class ClasseA extends Observable {
 
    // le champ que l'on veut surveiller
    private int compteur = 0;
 
    public int getCompteur() {
        return compteur;
    }
 
    public void incrementeCompteurDe(int i) {
        compteur += i;
        System.out.println("L'instance de classeA a son compteur qui passe à "+compteur+" ; elle notifie les observateurs.");
        setChanged();
        notifyObservers(compteur);
    }
 
}
 
// la classe qui observe
class ClasseB implements Observer {
 
    private String nomInstance = "";
 
    public ClasseB(String s) {
        nomInstance = s;
    }
 
    public void update(Observable o, Object arg) {
        System.out.println(nomInstance+" a été averti d'un changement dans l'objet qu'il observe, et dont le compteur est passé à "+arg);
    }
}
 
// "main" de démonstration
public class Exemple013_ObservableEtObserver {
 
    public static void main(String[] args) {
        ClasseA maClasseA = new ClasseA();
        ClasseB observateur1 = new ClasseB("Observateur1 (ClasseB)");
        ClasseB observateur2 = new ClasseB("Observateur2 (ClasseB)");
        maClasseA.addObserver(observateur1);
        maClasseA.addObserver(observateur2);
        for (int i=0; i<3; i++) {
            System.out.println("**");
            maClasseA.incrementeCompteurDe(1);
            try {Thread.sleep(1000);} catch (Exception e) {e.printStackTrace();}
        }
    }   
}

(3) PropertyChangeListener, qui détecte les modifications d'un objet.
Tutoriel : http://java.sun.com/docs/books/tutor...elistener.html

Exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
//par Nicolas_75
import java.beans.*;
 
// classe à observer
class ClasseAA {
 
    private int compteur = 0;
 
    public int getCompteur() {
        return compteur;
    }
 
    public void incrementeCompteurDe(int i) {
        int oldValue = compteur;
        compteur += i;
        System.out.println("L'instance de classeA a son compteur qui passe à "+compteur+" ; elle notifie les observateurs.");
        propertyChangeSupport.firePropertyChange("compteur", oldValue, compteur);
    }
 
    private PropertyChangeSupport propertyChangeSupport = new PropertyChangeSupport(this);
 
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        propertyChangeSupport.addPropertyChangeListener(listener);
    }
 
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        propertyChangeSupport.removePropertyChangeListener(listener);
    }
}
 
class ClasseBB {
 
    private String nomInstance = "";
 
    public ClasseBB(String s, ClasseAA classeAobservee) {
        nomInstance = s;
        classeAobservee.addPropertyChangeListener(new PropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent pce) {
                System.out.println(nomInstance+" a été averti d'un changement dans l'objet qu'il observe, et dont le compteur est passé de "+pce.getOldValue()+" à "+pce.getNewValue());
            }
        }
        );
    }
}
 
// "main" de démonstration
public class Exemple014_BeansChangePropertyListener {
 
     public static void main(String[] args) {
        ClasseAA maClasseA = new ClasseAA();
        ClasseBB observateur1 = new ClasseBB("Observateur1 (ClasseB)", maClasseA);
        ClasseBB observateur2 = new ClasseBB("Observateur2 (ClasseB)", maClasseA);
        for (int i=0; i<3; i++) {
            System.out.println("**");
            maClasseA.incrementeCompteurDe(1);
            try {Thread.sleep(1000);} catch (Exception e) {e.printStackTrace();}
        }
    }
}

Nicolas

ta 2 eme methode me parait tres interessant mais en fait j ai un probleme car ma 1 ere classe est deja etendue d une autre classe hors en java on ne peux heriter de 2 classe

Peut t on contourner ce dileme

et je te remercie de ta reponse tres elaboree

Mon principal probleme est que le setChanged est protected donc meme si je fais par exemple
Code:

1 2 Observable o = new Observable(); o.setChanger();
sa ne va evidement pas marcher .

Voyervous une autre methode pour acceder a cette methode ....

Comme dans l'exemple proposé par Nicolas, il te faut étendre la classe Observable pour accéder alors à la méthode setChanged().
Tu ne peux pas faire grand chose avec un Observable non étendu, il faut bien que tu gères des propriétés et/ou comportements propres à ta classe, non ?

oui je suis tout a fait d accord

en faitle truc cest que moi ma classe AA est deja etendu d une JFrame donc je ne peut plus l etendre a Observable voila pourquoi je cherche un moyen de contourner ce probleme d heritage

Salut,

Pourquoi ne pas créer ton propre Listener :

FAQ : Comment créer son propre Listener ?

a++

ouai j ai consulter ta faq mais je trouve sa assez delicat pour l adapter a un changement d un boolean

Bonjour,

Est-ce que tu n'essaies pas de sortir l'artillerie lourde pour rien ?
Ce booléen est bien modifié par une méthode, du type setBoolean, ou changeFlag, ... ?
Dans ce cas, tu peux lancer les actions que te souhaites à partir de là.
Les méthodes (2) ou (3) sont surtout utiles si tu veux rajouter dynamiquement des observateurs. Es-tu vraiment dans ce cas ?

Nicolas

ta tout a fait raison

merci :lefou: