Créer ses propres Listener

Version imprimable

27/05/2016, 18h52
alex5956

Créer ses propres Listener

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 ?

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:

1 2 3 public interface MachinListener { public void machin(MachinEvent e); }
et dans ton objet:
Code:

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

30/05/2016, 13h22
alex5956

reponse

j 'ai dumal à saisir , comment il fait la classe pour savoir si c est un clic ou non ?
30/05/2016, 13h47
tchize_

les clics, c'est géré par l'os et interfacé directement par awt via les ClickEvent.
31/05/2016, 09h24
alex5956

ok il faut les enregistrer dans une liste les listener apparement si j ai bien compris ce que tu me disait , mais pourquoi ?
31/05/2016, 10h16
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.

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

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
 
 
*
 * 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:

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 ?

Salut,

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

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
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:

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:

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:

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

31/05/2016, 11h45
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
31/05/2016, 12h00
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.
31/05/2016, 12h32
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
31/05/2016, 13h37
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.
31/05/2016, 18h25
alex5956

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

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 :

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

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

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:

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.

02/06/2016, 15h40
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
02/06/2016, 15h50
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).
25/06/2016, 16h49
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
25/06/2016, 18h06
joel.drigo
Citation:

Envoyé par alex5956

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.

Citation:

Envoyé par alex5956

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:

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:

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).
20/07/2016, 21h33
alex5956

okok merci dsl pour le retard