Discussion :

[AceSir]

Salut à tous !

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

Code :

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

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

[Pascmar]

Dans ce cas préfère cette solution :

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

[Gannon]

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

Code :

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

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.

[thelvin]

Mon favori à moi :

Code :

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

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.

[professeur shadoko]

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

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

[adiGuba]

Salut,

Répétitif, mais propre et flexible.

+1

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

Code :

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

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

[Pascmar]

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

[Gannon]

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 :

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
 
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()
        //...
    }
}

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

[AceSir]

Dans ce cas préfère cette solution :

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

Merci à tous en tout cas

[Pascmar]

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

Code :

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

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

Pas de soucis en principe

[professeur shadoko]

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"