Discussion :

[alex5956]

bonjour à tous ,

voila
je voudrais créer mon Listener un peu comme MouseListener qui gère un clic sur une fenêtre c est tres important pour moi , c'est pour le côté technique prinicpalement .

pourriez vous m 'aider ?

[tchize_]

il n'y a rien de compliqué coté technique, un listener c'est juste une interface. Tu enregistre quelque part dans ton objet les instances que l'on te file avec addXXXXXListener, et quand l'évènement à lieu, tu appelle la méthode de ton interface, pour chacun des instances:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public interface MachinListener {
    public void machin(MachinEvent e);
}

et dans ton objet:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Set<MachinListener> listenersMachin;
public void addMachinListener(MachinListener l){
   listenersMachin.add(l);
}
 
private void fireMachin(MachinEvent e){
   for (MachinListener l: listenersMachin){
      l.machin(e);
   }
}

Après si t'es en swing dans un composant graphique, il y a AWTEventMultiCaster qui t'évite de jouer avec le stockage de l'event
https://docs.oracle.com/javase/8/doc...lticaster.html

[alex5956]

j 'ai dumal à saisir , comment il fait la classe pour savoir si c est un clic ou non ?

[tchize_]

les clics, c'est géré par l'os et interfacé directement par awt via les ClickEvent.

[alex5956]

ok il faut les enregistrer dans une liste les listener apparement si j ai bien compris ce que tu me disait , mais pourquoi ?

[hwoarang]

C'est le fonctionnement de java qui est comme ca. Il aurait pu etre different mais c'est le choix qui a été fait. Il faut juste comprendre comment ca marche et, après, ca roule tout seul.

Si tu utilises AWT/Swing, il faut ajouter des listeners correpondant aux evenements qui t'interessent puis effectuer l'action qui va bien. Pour pouvoir en dire plus, il faudrait préciser ce que tu utilises comme techno et ce que tu veux faire plus précisément.

[alex5956]

ok j ai un peu de mal mais je pense que j'y suis presque voila ma classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ampoule;
 
import java.util.ArrayList;
 
/**
 *
 * @author Alexandre
 */
public class Ampoule implements Puissance{
 
    private String  nom ;
    private int numero ;
    private int puissance ;
    ArrayList<Puissance> mesPuissances = new ArrayList<Puissance>();
    public Ampoule (int puissance , String nom , int numero){
        this.nom = nom ;
        this.numero=numero;
        this.puissance=puissance ;  
        mesPuissances.add(this);
 
    }
    public void travail(){
        for(int i=this.puissance ; i>0 ; --i){
 
            System.out.println("l'ampoule a pour puissance"+i);
 
        } 
 
 
    }
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Ampoule monAmpoule = new Ampoule(100,"Ma première ampoule",5);
        monAmpoule.travail();
    }
 
 
 
    @Override
    public void changeAmpoule() {
        if(this.puissance==50){
      System.out.println("coucou");
        }
    }
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package ampoule;
 
import java.util.EventListener;
 
/**
 *
 * @author Alexandre
 */
public interface Puissance extends EventListener {
 
    public void changeAmpoule( );
 
}

pourque ma méthode changeAmpoule soit déclenchée à puissance =50 je dois faire quoi ?

[joel.drigo]

Salut,

Pour des évenements concernant des changements de propriétés, tu devrais plutôt utiliser java.beans.PropertyChangeSupport/java.beans.PropertyChangeListener.

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class Personne {
 
     public static final String PROPERTY_NOM = "NOM";
 
 
     private final PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
 
     private String nom;
     private String prenom;
 
     public String getNom() {
           return nom;
     }
 
    public void setNom(String nom) {
          String old = this.nom;
          this.nom = nom;
          changeSupport.firePropertyChange( PROPERTY_NOM, old, nom);
    }
 
    public void addPropertyChangeListener(PropertyChangeListener listener) {
		changeSupport.addPropertyChangeListener(listener);
    }
 
    public void addPropertyChangeListener(String property, PropertyChangeListener listener) {
		changeSupport.addPropertyChangeListener(property, listener);
    }
 
    public void removePropertyChangeListener(PropertyChangeListener listener) {
		changeSupport.removePropertyChangeListener(listener);
    }
 
    public void removePropertyChangeListener(String property, PropertyChangeListener listener) {
		changeSupport.removePropertyChangeListener(property, listener);
    }
 
}

Utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
personne = ...
personne.addPropertyChangeListener(Personne.PROPERTY_NOM, e-> System.out.println("Le nom a changé de " + e.getOldValue() +" à " + e.getNewValue());

Quand un code appellera

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

personne.setNom("Truc");

sur cette même instance, le message s'affichera...

Tu peux écouter toutes les propriétés d'un coup aussi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
personne.addPropertyChangeListener(e-> System.out.println("La propriété " + e.getPropertyName() + " a changé de " + e.getOldValue() +" à " + e.getNewValue());

[alex5956]

mais avec mon propre code c 'est possible ?c 'est ça que je veux savoir je veux créer mon ecouteur et mon évènement

[joel.drigo]

Tu peux te créer tes propres évenements et listeners, mais à quoi ça sert ? C'est plus simple d'utiliser quelque chose de déjà fait, non ? Si c'est juste pour l'exercice de le faire, on t'a déjà répondu dans le post 2.

[alex5956]

oui mais justement j ai posté mon prog mais je n arrive pas à effectuer ma méthode je ne sais pas ce qui va a pas , mon prog n est pas super compliqué vous devriez comprendre normalement

[joel.drigo]

Oui, enfin, ce n'est pas le problème de comprendre ton "programme". On t'a donné des exemples. C'est à toi de les appliquer à ton contexte. Ce qui ne devrait pas être compliqué, c'est de remplacer Personne par Ampoule, nom par puissance, et ainsi d'adapter mon exemple (par exemple) à ton cas particulier.

[alex5956]

c 'est ce que j ai fais non ? mon event ne se déclenche pas

[joel.drigo]

Tu n'as fait que créer une interface. Cela n'est évidemment pas suffisant : il n'y a déjà aucun lien entre cette interface et ta classe. Ta classe Ampoule ne traite aucun écouteur, ni aucun envoi d'évenement.

Reprenons. Dans un système évenementiel, il y a un eméteur d'évenement et des récepteurs d'évenement. Les récepteurs le sont parce qu'ils se sont enregistrés au près de l'émetteur en tant que tels : la communication se fait par écouteur (listener).

Il faut donc :

1. que la classe qui émet l'évenement puisse enregistrer une liste d'écouteurs : il lui faut donc une liste. On t'a donné différentes solutions pour ça :
   
   • soit tu as un attribut de type List, paramétré pour stocker des instances d'écouteur,
   • soit tu utilises une des classes de Java qui gèrent ça :
     
     • EventListenerList : plutôt prévue pour des évenements d'UI (c'est d'ailleurs une classe de Swing)
     • SwingPropertyChangeSupport : plutôt prévue pour des évenements concernant des changements de propriétés de composants graphiques Swing
     • PropertyChangeSupport : plutôt prévue pour des changements d'attributs (ce que j'ai montré dans mon exemple)
     • ...
     
     
     
   
   
   
2. Il faut à cette classe également des méthodes que les récepteurs vont appeler pour s'enregistrer.
   Dans le cas de la List, tu seras obligé de gérer correctement toi-même les enregistrements d'instances d'écouteurs dans la liste, d'écrire donc des méthodes, pour ajouter des éléments dans la liste, en vérifiant qu'elles n'y sont pas déjà, qu'on ne passe de null (pour éviter les NullPointerException), etc...
   Pour les autres cas, tu as déjà tout ça déjà fait, et il suffit d'appeler simplement les méthodes en question, et d'exporter en quelque sorte ces méthodes dans ta propre classe. Comme j'ai fait dans mon exemple.
3. Il faut que cette classe envoit les évenements au moment opportun selon la signification de l'évenement (un évenement peut vouloir qu'une valeur change, qu'une valeur à atteinte une limite, ou tout ce qu'on veut...). Dans mon exemple, j'envoi un évenement lorsque la valeur de l'attribut nom est modifiée par appel de la méthode setNom() en appelant la méthode firePropertyChange.
   Si tu implémentes toi-même cette méthode, il te faudra parcourir tous les écouteurs actuellement enregistrés et appeler la ou les méthodes d'écoutes prévus pour...comme on t'a montré dans le post 2.

Un évenement, ça peut être une simple valeur, une instance d'une classe avec plein de valeurs (l'ancienne, la nouvelle, etc), voire rien du tout (il suffit que la méthode de l'écouteur soit invoquée pour que le récepteur soit averti qu'il s'est passé quelquechose).

Si on reprend ton exemple d'Ampoule, de puissance et avec un PropertyChangeSupport, on peut avoir par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
public class Personne {
 
     public static final String PROPERTY_PUISSANCE = "PUISSANCE";
 
 
     private final PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
 
     private double puissance;
 
 
     public String getNom() {
           return nom;
     }
 
    public void setPuissance(double puissance) {
          double old = this.puissance;
          this.puissance = puissance;
          changeSupport.firePropertyChange( PROPERTY_PUISSANCE, old, puissance);
    }
 
    public void addPropertyChangeListener(PropertyChangeListener listener) {
		changeSupport.addPropertyChangeListener(listener);
    }
 
    public void addPropertyChangeListener(String property, PropertyChangeListener listener) {
		changeSupport.addPropertyChangeListener(property, listener);
    }
 
    public void removePropertyChangeListener(PropertyChangeListener listener) {
		changeSupport.removePropertyChangeListener(listener);
    }
 
    public void removePropertyChangeListener(String property, PropertyChangeListener listener) {
		changeSupport.removePropertyChangeListener(property, listener);
    }
 
}

on peut si on veut ajouter une méthode :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public void varierPuissance(double nouvellePuissance, int vitesse) {
      double step = (nouvellePuissance-puissance)/vitesse;
      double old = puissance;
      for(int i=0; i<vitesse; i++) {
          puissance+=step;
          changeSupport.firePropertyChange( PROPERTY_PUISSANCE, old, puissance); // envoi de l'évenement
          old = puissance;
      }
}

ou le faire dans un Timer, ou que sais-je... mais il faut écrire du code, et pas seulement créer une Interface.

[alex5956]

ok ça marche , super !! mais besoin de de faire plusieurs listeners si tu implemente action listener sur une fenetre avec plusieurs boutons et donc des this.AddActionListener( ....) dans ton traitement de la méthode à implémenter

actionPerformed (ActionEvent){


_là tu mets un switch selon les boutons cliqués pour les gérer

}

c est mieux que de parcourir tout les listener

[joel.drigo]

Quel rapport entre ton dernier message et ta question initiale ? Dans ton dernier message tu parles de l'enregistrement des écouteurs d'action (ActionListener) sur un composant graphique, pas de créer ses propres écouteurs ? (Si tu pouvais faire des phrases complètes aussi, ça permettrait de mieux comprendre ce que tu écris).

[alex5956]

re ! dsl pour le retard

mais on est d'accord pour dire que les évenement du jdk sont fait comme on vient d'en créer ,le truc c est que le traitement est invisible aux yeux de toute le monde ?

mnt est t il nécessaire de déclencher tous les évents à la fois ??et pourquoi ?un évenement = un seul ecouteur

[joel.drigo]

le truc c est que le traitement est invisible aux yeux de toute le monde ?

Pas vraiment : tu peux regarder les sources pour voir comment c'est fait.

est t il nécessaire de déclencher tous les évents à la fois ??et pourquoi ?un évenement = un seul ecouteur

On pourrait chercher à optimiser pour n'envoyer que les événements pour lesquels il existe au moins un écouteur d'enregistré, mais ce n'est pas pour gagner grand chose au détriment d'une complication inutile du code.
Et puis, ceci se fait parfois naturellement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
private void fireEvent(Event event) {
   for(Listener listener : listeners) {
           listener.handle(event);
   }
}

Si listeners, une List<Listener> est vide, aucun évenement n'est jamais envoyé à aucun écouteur. Inutile donc de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
private void fireEvent(Event event) {
   if ( !listeners.isEmpty() )  {
      for(Listener listener : listeners) {
           listener.handle(event);
      }
   }
}

ou encore ce test à l'endroit de l'appel du fireEvent() ce qui pourrait encore complexifier, pour peu qu'on est besoin de gérer des appels concurrents à la liste d'écouteurs.

Un évenement = un type d'écouteur en général (il n'y a pas vraiment de raison d'en avoir plusieurs quoique que ce n'est pas complètement exclu (on peut imaginer des cas où ça pourrait être utile). En revanche, un évenement peut être bien sûr écouté par plusieurs écouteurs, car plusieurs composants peuvent en avoir besoin (ça permet de découpler des traitements qui n'ont pas de rapport, mais qui se déclenchent sur un même événement).

[alex5956]

okok merci dsl pour le retard