Implémentation de ActionListener : récupérer this

Version imprimable

Salut à tous !

Je suis confronté à un problème technique... Si je fais :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class MaClasse { public MaClasse() { JButton bouton = new JButton(); bouton.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { } } } }
Comment je fais pour récupérer une référence sur MaClasse ? Car si j'utilise this, c'est une référence sur ActionListener...

Dans ce cas préfère cette solution :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
public class MaClasse implements ActionListener 
{
    private JButton bouton;
    public MaClasse() 
    {
        bouton = new JButton();
        bouton.addActionListener(this);
        ...
    }
 
    public void actionPerformed(ActionEvent e) 
    {
         if (e.getSource() == bouton) { ... }
    }
}

Il me semble qu'il est possible d'acceder a ta classe comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
public class MaClasse {
    public MaClasse() {
        JButton bouton = new JButton();
        bouton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
 
                  MaClass.this ...
            }
        }
    }
}

PS : La version de Pascmar est plus propre a mon gout.

Mon favori à moi :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MaClasse {
    public MaClasse() {
        JButton bouton = new JButton();
        bouton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
              butonPushed(e);
            }
        }
    }
    private void butonPushed(ActionEvent e) {
      // ...
    }
}

Répétitif, mais propre et flexible.

28/02/2013, 18h01
professeur shadoko

Citation:

Envoyé par Gannon

PS : La version de Pascmar est plus propre a mon gout.

pas au mien: c'est catégorisé anti-pattern!

Salut,

Citation:

Envoyé par thelvin

Répétitif, mais propre et flexible.

+1

Et en plus ca s'adaptera bien avec les method-references de Java 8 :
Code:

1 2 3 4 5 6 7 8 9 public class MaClasse { public MaClasse() { JButton bouton = new JButton(); bouton.addActionListener(this::butonPushed); } private void butonPushed(ActionEvent e) { // ... } }
a++

28/02/2013, 21h20
Pascmar

Citation:

pas au mien: c'est catégorisé anti-pattern!

Qu'entends-tu par là ? Pour ma part j'ai suivi la méthode de Delannoy (programmer en java, 5ème éd. p. 337).

Je sais pas si il frauderai mieux que je relance un sujet, selon vous quelle est la méthode la plus propre et pourquoi.

Personnellement j'ai pour habitude d'utilisez la solution 1 :

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
 
public class MaClasse {
 
    public MaClasse(){
        JButton bouton = new JButton();
        //Solution 1
        bouton.addActionListener(new ButtonClick());
 
        //Solution 2
        bouton.addActionListener(this.buttonClick);
 
        //Solution 3
        bouton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
              butonPushed(e);
            }
        });
 
       //Solution 4
       bouton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                //MaClasse.this.op1();
                //...
            }
        });
 
    }
 
     ;
    private ActionListener buttonClick = new ActionListener(){
        public void actionPerformed(ActionEvent e) {
            //MaClasse.this.function1() ;
            //...
        }
    };
 
    private class ButtonClick implements ActionListener{
        public void actionPerformed(ActionEvent e) {
            //MaClasse.this.function1()
            //...
        }
    }
 
    private void butonPushed(ActionEvent e){
        //this.function1()
        //...
    }
}

28/02/2013, 21h59
Sharcoux

Pour moi, il n'y a pas de réponse toute faite à cette question. C'est à toi de te demander :

- Est-ce que je risque de réutiliser mon actionListener ailleurs ? Dans un menu par exemple ? Auquel cas créer une classe ButtonClick me parait une bonne solution.

- Est-ce qu'il y aura d'autres occasion ou la fonction buttonPushed() sera executée ? La solution 3 pourrait alors être la meilleure.

- Est-ce que j'ai besoin d'accéder à buttonClick ailleur dans le code ? Est-ce que j'ai besoin de le stocker ? Besoin de setter et de getter associé ? Dans ce cas, solution 2.

Citation:
Envoyé par Pascmar
Dans ce cas préfère cette solution :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public class MaClasse implements ActionListener { private JButton bouton; public MaClasse() { bouton = new JButton(); bouton.addActionListener(this); ... } public void actionPerformed(ActionEvent e) { if (e.getSource() == bouton) { ... } } }
MaClasse hérite de JFrame. Pas de soucis de conflits ?

thelvin, ta méthode s’apparente aux signaux et slots de Qt en C++, j'aime particulièrement :)
Au début, je me forçais à créer une classe d'implémentation de ActionListener pour chaque action. Mais ça devient très vite intenable (surtout pour la génération de la Javadoc, un boulot interminable et rébarbatif). Mais je pense adopter cette méthode :P

Merci à tous en tout cas :D

01/03/2013, 10h26
Pascmar

Oui pardon, l'entête de la classe est en réalité :

Code:

public class MaClasse extends JFrame implements ActionListener{...}

Pas de soucis en principe :)
01/03/2013, 15h56
professeur shadoko

Citation:

Envoyé par Pascmar

Qu'entends-tu par là ? Pour ma part j'ai suivi la méthode de Delannoy (programmer en java, 5ème éd. p. 337).

comme toujours c'est une question d'appréciation un peu subjective et tout se discute.
Cette approche est connue comme le "switchboard Listener anti-pattern"