Discussion :

[Auteur]

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

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

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


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

[oneagaindoguys]

Quand tu fais

Code :

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

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 :

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

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.

[Auteur]

Quand tu fais

Code :

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

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 :

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

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

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() ?

[babycart]

Bonsoir,
Tu peux faire comme cela :

Code :

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

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 :

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

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 (?)

[oneagaindoguys]

ç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

[oneagaindoguys]

Bonsoir,
Tu peux faire comme cela :

Code :

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

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 :

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

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

[Auteur]

Code :

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

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

ou encore :

Code :

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

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

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

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

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

[oneagaindoguys]

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 :

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

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.

[Logan Mauzaize]

j'y ai pensé et testé : effectivement cela fonctionne. Mais, j'avoue avoir une certaine réticence à déclarer des variables dans des boucles (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.

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 !

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

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 :

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

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);
}

[adiGuba]

Salut,

Mais, j'avoue avoir une certaine réticence à déclarer des variables dans des boucles (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...

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

[Auteur]

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

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

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

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

[Beginner.]

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 :

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

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

[Auteur]

bonsoir,

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.

[Beginner.]

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.

[Logan Mauzaize]

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

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

[Auteur]

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.

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.

[Logan Mauzaize]

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 :

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

[Auteur]

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

intéressant 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.