Discussion :

[kerinel]

Bonjour,
une question peut-être pas aussi purement philosophique qu'on pourrait le penser: Comment bien implémenter un Listener ? Je vais illustrer avec un ActionListener mais ma question est valable pour tous les Listener.
La première façons consiste à faire en sorte que la classe que l'on construit implémente ActionListener:

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
 
public class ExempleUn extends ActionListener{
 
    public ExempleUn(){
 
         ...
 
         JButton b1 = new JButton("bouton1");
         b1.setActionCommand("lebouton1");
         b1.addActionListener(this);
 
         JTextField t1 = new JTextField();
         t1.setEctionCommand("lazonetexte1");
         t1.addActionListener(this);
 
         ...     
    }
 
    public void actionPerformed(ActionEvent e){
        String commande = e.getActionCommand();
        if (commande.equals("lebouton1")){
               //faire ce qu'il faut pour répondre un click sur le JButton b1
        }
        else if (commande.equals("lazonetexte1")){
               //faire ce qu'il faut pour répondre à "Entrer" sur le JtextField t1
        }
        else if ...
   }
 
}

Avec un nombre de bouton important, pour peu que les traitements ne soient pas "légers" (plusieurs lignes de code), la méthode actionPerformed devient assez rapidement illisible.

La deuxième solution consiste à utiliser les classes anonymes

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
 
public class ExempleDeux{
 
    public ExempleDeux(){
 
         ...
 
         JButton b1 = new JButton("bouton1");
         b1.setActionCommand("lebouton1");
         b1.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                          //faire ce qu'il faut pour répondre un click sur le JButton b1
        }});
 
         JTextField t1 = new JTextField();
         t1.setEctionCommand("lazonetexte1");
         t1.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                          //faire ce qu'il faut pour répondre à "Entrer" sur le JtextField t1
        }});
 
         ...     
    }
}

mais il est rarement possible de faire le traitement directement et on fait alors le plus souvent appel à une méthode "dédiée":

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
 
public class ExempleTrois{
 
    public ExempleTrois(){
 
         ...
 
         JButton b1 = new JButton("bouton1");
         b1.setActionCommand("lebouton1");
         b1.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                          this.repondreAuBoutonUn();
        }});
 
         JTextField t1 = new JTextField();
         t1.setEctionCommand("lazonetexte1");
         t1.addActionListener(new ActionListener(){
                public void actionPerformed(ActionEvent e){
                          this.repondreAuJTextFieldUn();
        }});
        ...     
    }
 
     public void repondreAuBoutonUn(){
               //faire ce qu'il faut pour répondre un click sur le JButton b1
    }
 
     public void repondreAuJTextFieldUn(){
               //faire ce qu'il faut pour répondre à "Entrer" sur le JtextField t1
    }
 
}

Et on peut du coup appliquer le même principe à ce qu'on avait sur l'exemple 1 ce qui rend la méthode actionPerformed un peu plus lisible

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 ExempleQuatre extends ActionListener{
 
    public ExempleQuatre(){
 
         ...
 
         JButton b1 = new JButton("bouton1");
         b1.setActionCommand("lebouton1");
         b1.addActionListener(this);
 
         JTextField t1 = new JTextField();
         t1.setEctionCommand("lazonetexte1");
         t1.addActionListener(this);
 
         ...     
    }
 
    public void actionPerformed(ActionEvent e){
        String commande = e.getActionCommand();
        if (commande.equals("lebouton1")){
               this.repondreAuBoutonUn();
        }
        else if (commande.equals("lazonetexte1")){
               this.repondreAuJTextFieldUn();
        }
        else if ...
   }
 
    public void repondreAuBoutonUn(){
               //faire ce qu'il faut pour répondre un click sur le JButton b1
    }
 
     public void repondreAuJTextFieldUn(){
               //faire ce qu'il faut pour répondre à "Entrer" sur le JtextField t1
    }
}

Ma question est donc parmis ces 4 méthodes (enfin surtout les deux dernières) laquelle est la meilleure ? Vous allez me répondre meilleure en quelle terme ? Ben justement, c'est un peu la question : les avantages de l'une ou l'autre en différents termes surtout de rapidité, sécurité, intégrité... car ici j'ai surtout vu le coté pratique à écrire (ce qui fit pencher pour la solution 3) mais ce n'est peut etre pas la meilleure sur d'autres critères ?

merci pour vos avis.

Bon code,
kerinel

[iohack]

Perso, voici comment je procède pour avoir un code lisible (peut-être qu'il y a mieux...) :
Je mets mes composants comme attributs du conteneur que je dérive (JFrame JPanel) :

Code :

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

1
2
3
4
5
 
public class MonPanel extends JPanel implements ActionListene, WindowListener etc.{
   private JButton bouton1;
   ... etc
}

Dans le constructeur de ce conteneur ,j'appelle :
- une méthode qui va instancier les composants puis les mettre en forme dans les layouts.
- une méthode qui va ajouter tous les listeners à mes composants :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public MonPanel(...){
   this.initLayouts();
   this.initListeners();
   ...
}
public void initLayouts(){
   this.monSousPanel.add(bouton1);
   ...
}
public void initListeners(){
   this.bouton1.addActionListener(this);
   ...
}

ensuite dans la méthode actionPerformed, il ne reste plus qu'à appeler la méthode adéquat en fonction de la source de l'événement :

Code :

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

1
2
3
4
5
 
public void actionPerformed(ActionEvent e){
   if(e.getSource()==this.bouton1) this.actionBouton1();
   if(e.getSource()==this.bouton2) this.actionBouton2();
   ...

Voilà pour ma façon de faire.
Sinon jai horreur des classes anonymes, qui se révèlent très rapides à écrire dans le cadre d'un utilisation très simple mais bordéliques par la suite. Exemple de fermeture de fenetre :

Code :

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

1
2
3
4
5
6
 
this.addWindowListener(new WindowAdapter(){
  public void windowClosing(WindowEvent e){
     this.dispose();
  }
});

Je sais que ce code est inutile (DISPOSE_ON_CLOSE), c'est pour l'exemple. Procéder de cette manière interdit de par la visibilité l'accès aux attributs de mon conteneur. Cette interdiction n'est levée que par la déclaration des attributs en statique, ce qui est loin d'être le top...
De plus, le jour où je dois modifier mon code à la fermeture de la fenêtre, ça devient un vrai bordel à gérer...

Voilà si d'autres ont des techniques miracles, ils sont les bienvenus