Comment créer un Action Listener avec une variable de boucle ?

bonjour,

dans une fonction j'ai une boucle qui me permet de créer 3 boutons et leur ActionListener. Je voudrais passer en paramètre à la fonction appelée lors du clic sur le bouton le contenu de la variable de boucle :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 JButton btn[]= new JButton[3]; int i; for (i=0; i<3; i++) { btn[i]=new JButton("Bouton " + i); btn[i].addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { System.out.println(i); } }); }
Malheureusement au moment de la compilation j'ai cette erreur au niveau du println() :

Citation:

error: local variable i is accessed from within inner class; needs to be declared final
System.out.println("bouton n°" + i);

Si je déclare i en final int mon erreur se trouve au niveau du for :aie:

D'où ma question : comment je peux passer le contenu de i ?

Quand tu fais

Code:

new ActionListener()

tu es dans une classe interne, et la variable i, n'est plus visible. Il faut alors déclarer ta variable i en variable globale. C'est à dire avec les attributs de la classe.
Code:

1 2 3 4 5 6 public class MaClasse { int i; ... public void taMethode() { for (i=0...
A ta place je ne m'y prendrais pas comme ça. Ta classe devrait implémenter ActionListener et dans la méthode actionPerformed, tu boucles sur le tableau, tu intercepte le bouton source et avec un switch case tu gère l'action du bouton en fonction de sa position dans le tableau.

Citation:
Envoyé par oneagaindoguys
Quand tu fais

Code:

new ActionListener()

tu es dans une classe interne, et la variable i, n'est plus visible. Il faut alors déclarer ta variable i en variable globale. C'est à dire avec les attributs de la classe.
Code:

1 2 3 4 5 6 public class MaClasse { int i; ... public void taMethode() { for (i=0...
ça ne fonctionne pas seule la dernière valeur de i est prise en compte...

Citation:

Envoyé par oneagaindoguys

A ta place je ne m'y prendrais pas comme ça. Ta classe devrait implémenter ActionListener et dans la méthode actionPerformed, tu boucles sur le tableau, tu intercepte le bouton source et avec un switch case tu gère l'action du bouton en fonction de sa position dans le tableau.

Dans ce cas quelle propriété du bouton est testée dans le switch case ? Comment je peux les différencier les uns des autres ? En utilisant setName() ?

Bonsoir,
Tu peux faire comme cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
for (int i=0; i<3; i++)         {
 final int iTmp = i;
 btn[i]=new JButton("Bouton " + i);             
 btn[i].addActionListener(new ActionListener() {

   @Override
   public void actionPerformed(ActionEvent e) {
       System.out.println(iTmp);                 
   }             
});         
}

ou encore :

Code:

1
2
3
4
5
6
7
8
9
10
11
for (int i=0; i<3; i++)         {
 btn[i]=new JButton("Bouton " + i);  
 btn[i].setActionCommand(Integer.toString(i));           
 btn[i].addActionListener(new ActionListener() {

   @Override
   public void actionPerformed(ActionEvent e) {
       System.out.println(e.getActionCommand());                 
   }             
});         
}

Mais tout dépend de ce que tu veux faire au final (?)

Citation:

Envoyé par Auteur

ça ne fonctionne pas seule la dernière valeur de i est prise en compte...

Dans ce cas quelle propriété du bouton est testée dans le switch case ? Comment je peux les différencier les uns des autres ? En utilisant setName() ?

Lorsque tu instancies un bouton la JVM lui attribue une place en mémoire. C'est l'adresse mémoire qui est prise en compte.

Si tu veux envoies ton code, je vais essayer de l'adapter

Citation:

Envoyé par babycart

Bonsoir,
Tu peux faire comme cela :

Code:

1
2
3
4
5
6
7
8
9
10
11
for (int i=0; i<3; i++)         {
 final int iTmp = i;
 btn[i]=new JButton("Bouton " + i);             
 btn[i].addActionListener(new ActionListener() {

   @Override
   public void actionPerformed(ActionEvent e) {
       System.out.println(iTmp);                 
   }             
});         
}

ou encore :

Code:

1
2
3
4
5
6
7
8
9
10
11
for (int i=0; i<3; i++)         {
 btn[i]=new JButton("Bouton " + i);  
 btn[i].setActionCommand(Integer.toString(i));           
 btn[i].addActionListener(new ActionListener() {

   @Override
   public void actionPerformed(ActionEvent e) {
       System.out.println(e.getActionCommand());                 
   }             
});         
}

Mais tout dépend de ce que tu veux faire au final (?)

Le mieux, est que la classa implémente ActionListener

Citation:
Envoyé par babycart
Code:

1 2 3 4 5 6 7 8 9 10 11 for (int i=0; i<3; i++) { final int iTmp = i; btn[i]=new JButton("Bouton " + i); btn[i].addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { System.out.println(iTmp); } }); }
j'y ai pensé et testé : effectivement cela fonctionne. Mais, j'avoue avoir une certaine réticence à déclarer des variables dans des boucles :aie: (sans doute parce que j'ai dans le passé utilisé des langages qui interdisent ce cas de figure).

Par ailleurs, au niveau de la mémoire comment sont gérées les déclarations dans les boucles ?
Citation:
Envoyé par babycart
ou encore :
Code:

1 2 3 4 5 6 7 8 9 10 11 for (int i=0; i<3; i++) { btn[i]=new JButton("Bouton " + i); btn[i].setActionCommand(Integer.toString(i)); btn[i].addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { System.out.println(e.getActionCommand()); } }); }
pas mal :) Je testerai dès que possible ;) Mais une question qu'est-ce que la méthode setActionCommand() ? La javadoc n'est pas très explicite

Citation:

public void setActionCommand(String actionCommand)
Sets the action command for this button.

:aie:

Citation:

Envoyé par oneagaindoguys

Lorsque tu instancies un bouton la JVM lui attribue une place en mémoire. C'est l'adresse mémoire qui est prise en compte.

je testerai donc cette possibilité avec le méthode equals de getSource().

Citation:

Envoyé par oneagaindoguys

Si tu veux envoies ton code, je vais essayer de l'adapter

non, je préfère le faire moi même à partir des suggestions postées ;)

Citation:

Envoyé par Auteur

non, je préfère le faire moi même à partir des suggestions postées ;)

Eh bien si tu veux coder correctement fait ta classe implémenter ActionListener.
Code:

1 2 3 4 5 6 7 8 public void actionPerformed(ActionEvent e) { for (int i=0; i<btn.length; i++) { if (e.getSource().equals(btn[i])) { switch... //ici tu gères l'action en fonction du boutton } }
ActionListener est une interface et instancier une interface n'est pas ce qui est de plus cohérent. Imagine tu 30 boutons dans ton tableau, tu instancie 30 ActionListener, c'est lourd.

Citation:

Envoyé par Auteur

j'y ai pensé et testé : effectivement cela fonctionne. Mais, j'avoue avoir une certaine réticence à déclarer des variables dans des boucles :aie: (sans doute parce que j'ai dans le passé utilisé des langages qui interdisent ce cas de figure).

C'est bien comme cela qu'il faut faire rapidement.

Citation:

Envoyé par Auteur

Par ailleurs, au niveau de la mémoire comment sont gérées les déclarations dans les boucles ?

Quand tu crées une classe anonyme, le compilateur génère une vraie classe.
Si tu utilises des variables locales à l'instanciation de celle-ci alors le compilateur va simplement rajouter des attributs finaux dans la classe générée et les alimenter au niveau de l'instanciation de celle-ci.
C'est pourquoi les attributs doivent être finaux pour que cela fonctionne.
Le même principe s'applique si tu fais appels à des attributs et/ou méthode de "this". Le compilateur ajoute un attribut final du type de la classe qui génère la classe anonyme et alimente cet attribut au moment de l'instanciation.
Le même principe est également appliqué aux inner class non static !

Citation:

Envoyé par Auteur

pas mal :) Je testerai dès que possible ;) Mais une question qu'est-ce que la méthode setActionCommand() ? La javadoc n'est pas très explicite :aie:

Il s'agit d'une simple String permettant d'identifier le comportement du bouton. Par exemple une ActionCommand "delete" pourrait être utilisé pour plusieurs boutons mais un seul listener est nécessaire pour le gérer.

Dans ce cas il ne faudrait pas instancier un action listener pour chaque élément de la boucle :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 ActionListener listener = new ActionListener() { public void actionPerformed(ActionEvent e) { switch (Integer.parseInt(e.getActionCommand()) { } } } for (int i=0; i < 10; i++) { JButton button = new JButton("Button #" + i); button.setActionCommand(""+i); button.addActionListener(listener); myPanel.add(button); }

Salut,

Citation:

Envoyé par Auteur

Mais, j'avoue avoir une certaine réticence à déclarer des variables dans des boucles :aie: (sans doute parce que j'ai dans le passé utilisé des langages qui interdisent ce cas de figure).

Pourquoi ??????????

Au contraire même c'est plus propre si la variable n'est utilisé que dans la boucle...

Citation:

Envoyé par Auteur

Par ailleurs, au niveau de la mémoire comment sont gérées les déclarations dans les boucles ?

Il n'y a aucun soucis avec cela...

a++

Citation:

Envoyé par adiGuba

Pourquoi ??????????

Au contraire même c'est plus propre si la variable n'est utilisé que dans la boucle...

L'habitude d'utiliser des langages propriétaires à programmation séquentielle où la déclaration de variables au milieu du code est proscrite ;)

Je vais étudier vos exemples et voir ce qui convient le mieux dans mon cas ;)

bonsoir,

j'ai étudié attentivement vos réponses et j'ai fait ceci :

Une classe dérivée de JButton ce qui m'a permis de créer mon addActionListener() qui prend comme paramètre le listener et un entier (c'est ce que je souhaite récupérer)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public class CustomJButton extends JButton { private int param; public CustomJButton(String label) { super(label); } public void addActionListener(ActionListener listener, int param) { super.addActionListener(listener); this.param = param; } public int getParam() { return this.param; } }
Ensuite au moment de la création de mes boutons j'ai cette fonction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 int i; CustomJButton btn[] = new CustomJButton[3]; ActionListener aListener = new ActionListener() { @Override public void actionPerformed(ActionEvent e) { CustomJButton source; source = (CustomJButton)e.getSource(); System.out.println(source.getParam()); } }; for (i=0; i<3; i++) { btn[i] = new CustomJButton("Bouton " + i); btn[i].addActionListener(aListener, i); }
Qu'en pensez-vous ?

[edit]
Je constate que je peux appliquer ce code à des composants ne possédant pas la méthode setActionCommand() ou ayant un écouteur autre que ActionListener. Je peux même passer des paramètres autres qu'un entier.

Au final c'est ce que je souhaitais faire car mon problème concernait des JButon mais aussi des JSpinner.

Est-ce que cette façon de faire est correcte ?
[/edit]

Citation:
Envoyé par Auteur
bonsoir,

j'ai étudié attentivement vos réponses et j'ai fait ceci :

Une classe dérivée de JButton ce qui m'a permis de créer mon addActionListener() qui prend comme paramètre le listener et un entier (c'est ce que je souhaite récupérer)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public class CustomJButton extends JButton { private int param; public CustomJButton(String label) { super(label); } public void addActionListener(ActionListener listener, int param) { super.addActionListener(listener); this.param = param; } public int getParam() { return this.param; } }
Ensuite au moment de la création de mes boutons j'ai cette fonction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 int i; CustomJButton btn[] = new CustomJButton[3]; ActionListener aListener = new ActionListener() { @Override public void actionPerformed(ActionEvent e) { CustomJButton source; source = (CustomJButton)e.getSource(); System.out.println(source.getParam()); } }; for (i=0; i<3; i++) { btn[i] = new CustomJButton("Bouton " + i); btn[i].addActionListener(aListener, i); }
Qu'en pensez-vous ?

[edit]
Je constate que je peux appliquer ce code à des composants ne possédant pas la méthode setActionCommand() ou ayant un écouteur autre que ActionListener. Je peux même passer des paramètres autres qu'un entier.

Au final c'est ce que je souhaitais faire car mon problème concernait des JButon mais aussi des JSpinner.

Est-ce que cette façon de faire est correcte ?
[/edit]
Je débute en Java et C# donc je ne pourrais pas t'aider mais j'aimerais quand même comprendre ton problème histoire d'apprendre... : Est-ce que le but est de pouvoir identifier le bouton sur lequel on a cliqué ?

Merci.

bonsoir,

Citation:

Envoyé par Beginner.

Je débute en Java et C# donc je ne pourrais pas t'aider mais j'aimerais quand même comprendre ton problème histoire d'apprendre... : Est-ce que le but est de pouvoir identifier le bouton sur lequel on a cliqué ?

Merci.

Oui, mais pas seulement.

Des composants de mon interface (JButton, JSpinner entre autres) doivent interagir entre eux. Par exemple mon bouton i doit changer la valeur du JSpinner i et (i+3). Je ne souhaitais pas réaliser de boucles ou de conditions qui ferait que le code de ma fonction deviendrait rapidement indigeste.

En passant et en récupérant directement la valeur i, je peux cibler directement les composants voulus ;)

Mais je souhaite quand même l'avis de personnes plus aguerries sur mon code pour savoir si cette façon de procéder est correcte.

Citation:

Envoyé par Auteur

bonsoir,

Oui, mais pas seulement.

Des composants de mon interface (JButton, JSpinner entre autres) doivent interagir entre eux. Par exemple mon bouton i doit changer la valeur du JSpinner i et (i+3). Je ne souhaitais pas réaliser de boucles ou de conditions qui ferait que le code de ma fonction deviendrait rapidement indigeste.

En passant et en récupérant directement la valeur i, je peux cibler directement les composants voulus ;)

Mais je souhaite quand même l'avis de personnes plus aguerries sur mon code pour savoir si cette façon de procéder est correcte.

Ah ok si j'ai posé la question c'est parce que ta solution m'a fait penser à ce qu'explique Claude Delannoy dans son livre sur Java, je vais revoir ça d'ailleurs...

EDIT : Il explique cela au chapitre : 4- Gestion de plusieurs composants dans lequel il y a un sous paragraphe : 4.2.2 Une seule classe écouteur pour chaque buttons.

Pourquoi ajouter un paramètre à la méthode addActionListener et pas simplement un couple classique getter/setter ?

Tu pourrais faire une interface qui correspond à cela et faire implémenter ton interface aux composants qui t'intéressent.

Si tu as besoin de lier spécifiquement certains composants, tu peux utiliser un "repository" dans lequel tu crées la liaison et leurs données le même nom (propriété name de tout composant) pour les identifier.

Ex:

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
public class SpinnerListAndButtonRepositoryItem {
  public JSpinner spinner1;
  public JSpinner spinner2;
  public JButton button;
}
public class SpinnerListAndButtonRepository {
  public final Map<String, SpinnerListAndButtonRepositoryItem> items = new HashMap<String, SpinnerListAndButtonRepositoryItem>();
}
public class Gui {
  public final SpinnerListAndButtonRepository repository = new SpinnerListAndButtonRepository();
  public final ActionListener actionListener = new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      Component component = (Component) e.getSource();
      SpinnerListAndButtonRepositoryItem item = repository.items.get(component.getName());
      // do the job
    }
  }
  public void addButton(String name) {
    JButton newButton = new JButton(name);
    newButton.setActionCommand("do");
    newButton.setName(name);
    addButton(newButton);
  }
  public void addButton(JButton newButton) {
    newButton.addActionListener(actionListener);
    //TODO Check previously set button (if any)
    getItem(newButton.getName()).button = newButton;
    //TODO Adds button to the target container
  }
  public SpinnerListAndButtonRepositoryItem getItem(String name) {
    SpinnerListAndButtonRepositoryItem  item = repository.get(name);
    if (item == null) {
      item = new SpinnerListAndButtonRepositoryItem();
      repository.put(name, item);
    }
    return item;
  }
}

Merci Nemek pour ton exemple, mais je me considère comme débutant en java et je ne connais pas les "repository".
Mais si je comprends bien ton code il s'agit de placer des paramètres dans une pile au moment de la création des objets puis de les dépiler lorsque les événements sont déclenchés.

Citation:

Envoyé par Nemek

Pourquoi ajouter un paramètre à la méthode addActionListener et pas simplement un couple classique getter/setter ?

oui c'est vrai pour le coup je me suis un peu compliqué la vie. :aie:

C'est plus une problématique "objet" qu'un problème Java : comment lier plusieurs objets entre eux ?

Soit tu crées des attributs aux niveaux de ces objets en fonction de la navigabilité, soit tu crées un objet conteneur qui liste ces objets.

Schématiquement ca donne un truc du genre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 Liaison directe : ----------------- ************* ************ * Objet 1 *---------* Objet 2 * ************* ************ Conteneur liant : ----------------- ************* /-* Objet 1 * / ************* *************** / * Conteneur *- *************** \ \ ************* \-* Objet 2 * *************
Ensuite pour retrouver le conteneur on utilise un dictionnaire (ou une Map en Java) que l'on identifie par le nom du composant.

Le choix entre les deux types de liaison dépend de pas mal de choses comme la dépendance entre les classes liées, la responsabilité de la liaison, la "distance dans le code", etc.

Citation:

Envoyé par Nemek

soit tu crées un objet conteneur qui liste ces objets.

intéressant :ccool: Je crois que je vais devoir utiliser ce genre d'objet dans mon application notamment pour la gestion des fenêtres (JFrame).

Merci à vous tous pour votre aide et vos éclaircissements.