| ← (précédent) D.2 Les bases de la programmation graphique : fenêtre dynamique |
| D.4 Evènements sur les cases à cocher → |
| Accueil ↔ S O M M A I R E |
D.3 Evènements sur les boutons simples |
|
Avant toute chose, sachez que le clic sur un bouton peut se réaliser de 2 façons différentes : D' abord la façon classique : avec la souris, on clique sur le bouton. Une autre façon consiste à sélectionner le bouton grâce à la touche tabulation (pointillés sur le bouton), puis on appui sur la barre d' espace du clavier. C' est le même effet. |
| L' évènement généré par le clic sur un bouton est traité par la méthode (forcément prédéfinie) actionPerformed(). Cette méthode est déclarée : public void actionPerforme(ActionEvent a) dans l'interface ActionListener. Laquelle ne possède que cette méthode là. D'ores et déjà , il n'y a pas de classe type Adapter. Puisqu'il ny a qu'une seule méthode à redéfinir. |
Exemple 1 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame
6. {
7. public Fenetre()
8. {
9. setTitle("Une fenetre dynamique");
10. Container c = getContentPane();
11. c.setBackground(Color.gray);
12. setSize(500, 300);
13. c.setLayout(new FlowLayout());
14. JButton bouton = new JButton("bouton simple");
15. c.add(bouton);
16. setLocationRelativeTo(this.getParent());
17. bouton.addActionListener(new EcouteurDeBoutons() );
18. setDefaultCloseOperation(3);
19. }
20. }
21.
22.
23.
24. class EcouteurDeBoutons implements ActionListener
25. {
26. public void actionPerformed(ActionEvent a)
27. {
28. System.out.println("Vous venez de cliquer sur le bouton");
29. }
30. }
31.
32.
33. public class TesterClicBouton
34. {
35. public static void main(String [] args)
36. {
37. JFrame f = new Fenetre();
38. f.setVisible(true);
39. }
40. }
|
|
Compilez puis exécutez ce programme, il sera affiché : Une fenêtre graphique de fond gris sur lequel se trouve un bouton sur lequel on peut lire : bouton simple. Cliquez sur ce bouton et il sera affiché : Vous venez de cliquer sur le bouton. Explications : Ligne 13 : au lieu de faire : FlowLayout miseENforme = new FlowLayout(); Puis de mettre miseENforme dans les parenthèses de la méthode setLayout appliquée au conteneur c. J' ai préféré mettre sirectement new FlowLayout(). C' est la même chose. De même, ligne 17 : au lieu de faire EcouteruDeBoutons eb = new EcouteurDeBoutons(); Puis de mettre eb dans les parenthèses de la méthode addActionListener(). J'ai préféré y mettre directement new EcouteurDeBoutons(). C' est la même chose. Ligne 11 : j'ai utilisé une nouvelle couleur pour colorer la fenêtre. C'est la constante Color.gray = couleur grise. Ligne 14 : j'ai créé un bouton grâce à la classe JButton. Puis j'ai ajouté ce bouton dans le conteneur c. Ligne 15. Ligne 17 : l'objet source de l'évènement étant le bouton, j'associe au bouton l'objet EcouteurDeBouton qui est donc new EcouteurDeBouton(). La classe EcouteurDeBouton implémente l'interface ActionListener parce que cette interface contient la méthode permettant de traiter l'évènement clic sur un bouton. N'oubliez pas. Si après avoir lu plusieurs fois, vous ne comprenez toujours pas un exemple. Mon adresse électronique est webmaster@debutantprogjava.com |
Exemple 2 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame
6. {
7. public Fenetre()
8. {
9. setTitle("Une fenetre dynamique");
10. Container c = getContentPane();
11. c.setBackground(Color.gray);
12. setSize(500, 300);
13. c.setLayout(new FlowLayout());
14. JButton bouton1 = new JButton("bouton A");
15. JButton bouton2 = new JButton("bouton B");
16. c.add(bouton1); c.add(bouton2);
17. setLocationRelativeTo(this.getParent());
18. bouton1.addActionListener(new EcouteurDeBoutons() );
19. bouton2.addActionListener(new EcouteurDeBoutons() );
20. setDefaultCloseOperation(3);
21. }
22. }
23.
24. class EcouteurDeBoutons implements ActionListener
25. {
26. public void actionPerformed(ActionEvent a)
27. {
28. System.out.println("Vous venez de cliquer sur un bouton");
29. }
30. }
31.
32.
33. public class TesterClicBouton2
34. {
35. public static void main(String [] args)
36. {
37. JFrame f = new Fenetre();
38. f.setVisible(true);
39. }
40. }
|
|
Compilez puis exécutez ce programme, il sera affiché : Une fenêtre graphique de fond gris sur lequel se trouve 2 boutons sur lesquels on peut lire, respectivement : bouton A et bouton B. Cliquez sur n'importe lequel des 2 boutons, il sera affiché le même message : Vous venez de cliquer sur un bouton. Explications : Même explication qu' à l'exemple 1. Sauf qu' ici, nous avons 2 boutons. Le clic sur chacun des 2 boutons conduit au même message. En pratique, l'action sur chaque bouton doit avoir une réponse différente. Sinon, à quoi ça sert d'avoir 2 boutons. Pour cela, il faudra que le programme puisse identifier chacun des boutons. C'est qui se passe dans l'exemple suivant. |
|
La méthode actionPerformed(), comme vous pouvez le voir en ligne 26, requiert un argument de type ActionEvent. l' objet "a" est un évènement
comme comme l'objet MouseEvent "e". La classe ActionEvent possède une méthode (getSource() ), héritée en fait de la classe EventObject, qui permet de distinguer différents boutons dans une même fenêtre graphique. Pour ce faire, on écrira un code dans le genre : if(a.getSource() == bouton1) . "a" étant bien entendu l'objet de type ActionEvent. Donc, on sera obligé d'utiliser la variable bouton1 dans une classe différente que celle dans laquelle elle a été créée. Voilà qui nous oblige alors de déclarer la variable bouton1 et aussi la variable bouton2 hors de toute méthode de la classe Fenetre. Mais en même temps, l'encapsulation fortement recommandée en POO nous oblige (presque) à déclarer la variable de JButton en private. Que faire alors ? ... Solution, utiliser la méthode actionPerformed() dans la classe Fenetre. Puisque cette méthode appartient à l'interface ActionListener, nous sommes alors obligés de faire en sorte que la classe Fenetre implémente cette interface. |
Exemple 3 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame implements ActionListener
6. {
7. private JButton bouton1, bouton2;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(Color.gray);
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15. bouton1 = new JButton("BOUTON 1");
16. bouton2 = new JButton("BOUTON 2");
17. c.add(bouton1); c.add(bouton2);
18. setLocationRelativeTo(this.getParent());
19. bouton1.addActionListener(this);
20. bouton2.addActionListener(this);
20. setDefaultCloseOperation(3);
21. }
22. public void actionPerformed(ActionEvent a)
23. {
24. if(a.getSource() == bouton1 )
25. { System.out.println("Vous avez cliqué sur BOUTON 1.");}
26. else
27. { System.out.println("Vous avez cliqué sur BOUTON 2.");}
28. }
29.
30. }
31.
32.
33. public class TesterClicBoutons3
34. {
35. public static void main(String [] args)
36. {
37. JFrame f = new Fenetre();
38. f.setVisible(true);
39. }
40. }
|
|
Compilez puis exécutez ce programme, il sera affiché : Une fenêtre graphique de fond gris sur lequel se trouve 2 boutons sur lesquels on peut lire, respectivement : bouton 1 et bouton 2. Cliquez sur le bouton "BOUTON 1", il sera affiché le message : Vous avez cliqué sur BOUTON 1. Cliquez sur le bouton "BOUTON 2", il sera affiché le message : Vous avez cliqué sur BOUTON 2. Explications : if(a.getSource() == bouton1 ) veut dire : si la source de l'action est bouton1. Dans ca cas, le message sur la fenêtre console sera : Vous avez cliqué sur BOUTON 1. else (sinon), la message sera : Vous avez cliqué sur BOUTON 2 Ce n'est pas compliqué comme vous pouvez le constater. |
|
Je tiens à préciser, même si je suis sûr que vous l'avez compris, que le nom qui apparaît sur le bouton dans la fenêtre graphique n'est pas le
nom de l'objet bouton. Quand on écrit : JButton bouton = new JButton("BOUTON"); bouton est le nom de l'objet bouton de type JButton. Et BOUTON est le nom qui apparaît sur le composant graphique. Pourquoi je tiens tellement à préciser cela ici ? ... parcequ'il existe une autre méthode permettant d'identifier le bouton. Et cette fois, elle s'adresse au nom qui se trouve sur le bouton. C' est la méthode getActionCommand(). Exemple suivant : |
Exemple 4 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame implements ActionListener
6. {
7. private JButton bouton1, bouton2;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(Color.gray);
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15. bouton1 = new JButton("BOUTON 1");
16. bouton2 = new JButton("BOUTON 2");
17. c.add(bouton1); c.add(bouton2);
18. setLocationRelativeTo(this.getParent());
19. bouton1.addActionListener(this);
20. bouton2.addActionListener(this);
20. setDefaultCloseOperation(3);
21. }
22. public void actionPerformed(ActionEvent a)
23. {
24. if(a.getActionCommand() == "BOUTON 1")
25. { System.out.println("Vous avez cliqué sur BOUTON 1.");}
26. else
27. { System.out.println("Vous avez cliqué sur BOUTON 2.");}
28. }
29.
30. }
31.
32.
33. public class TesterClicBoutons4
34. {
35. public static void main(String [] args)
36. {
37. JFrame f = new Fenetre();
38. f.setVisible(true);
39. }
40. }
|
|
Compilez puis exécutez ce programme. Il se passera la même chose que l'exemple 3. Toutefois, le code a changé. En fait, seule la ligne 24 a
changé. if(a.getActionCommand() == "BOUTON 1") veut dire : si la chaine de caractères inscrite sur un bouton est "BOUTON 1".
En effet, la méthode getActionCommand() retourne la chaine de caractères qui se trouve sur le bouton. |
|
Reparlons un peu des méthodes getSource() et getActionCommand(). La méthode getSource() fournit une référence de type Object de l'objet ayant déclenché l'évènement. Autrement dit, lorsqu'on écrit : if(a.getSource() == bouton1), on veut dire, si l'objet ayant déclenché l' évènement est bouton1. Et ça ne veut surtout pas dire : si le bouton ayant déclenché l'évènement est bouton1. Pourquoi cette précision ? ... parce que la méthode getSOurce() est présente dans toutes les classes évènement. : MouseEvent, ActionEvent, etc.... Ce qui signifie en fin de compte que cette méthode sera utilisée pour identifier n'importe quel composant graphique. La méthode getActionCommand() fournit une référence de type String. Elle ne s'applique pas à tous les composants. Seulement aux composants qui génèrent un évènement traité par la méthode actionPerformed(). La référence de type String fournit est, par défaut, celle de la chaine de caractères associée au composant graphique. Dans le cas d'un bouton, c'est le nom sur le bouton. Dans le cas d'une case à cocher, c'est le nom associé à la case à cocher. Mais on peut demander à la méthode getActionCommand() de fournir une autre chaine de caractères. Celle qu'on aura pris le soin de fabriquer grâce à la méthode setActionCommand(). Par exemple pour un bouton appelé bouton1, on écrira : bouton1.setActionCommand("le bouton rouge"); Dans ce cas, la méthode getActionCommand() fournira la référence de type String, de la chaine de caractères "le bouton rouge" au lieu de fournir celle de la chaine qui est inscrite sur le bouton et que tout le mode peut voir sur le bouton dans la fenêtre graphique. Dans certains problèmes à résoudre, vous serez amenés à créer un objet écouteur pour chaque bouton. Mais peut-être devrais-je dire, une classe écouteur pour chaque composant. Exemple suivant. |
Exemple 5 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame
6. {
7. private JButton bouton1, bouton2;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(Color.gray);
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15. bouton1 = new JButton("BOUTON 1");
16. bouton2 = new JButton("BOUTON 2");
17. c.add(bouton1); c.add(bouton2);
18. setLocationRelativeTo(this.getParent());
19. bouton1.addActionListener(new EcouteurBouton1() );
20. bouton2.addActionListener(new EcouteurBouton2() );
20. setDefaultCloseOperation(3);
21. }
22. }
23.
24. class EcouteurBouton1 implements ActionListener
25. {
26. public void actionPerformed(ActionEvent a1)
27. {
28. System.out.println("Vous avez cliqué sur BOUTON 1.");
29. }
30. }
31.
32. class EcouteurBouton2 implements ActionListener
33. {
34. public void actionPerformed(ActionEvent a2)
35. {
36. System.out.println("Vous avez cliqué sur BOUTON 2.");
37. }
38. }
39.
40. public class TesterClicBoutons5
41. {
42. public static void main(String [] args)
43. {
44. JFrame f = new Fenetre();
45. f.setVisible(true);
46. }
47. }
|
|
Compilez puis exécutez ce programme. Il se passera la même chose que l'exemple 3 ou 4. Cette fois, plus besoin d'identifier le bouton. Chaque
bouton est associé à son propre objet écouteur. Donc, sa propre méthode actionPerformed(). Dans les cas où le problème à résoudre est lourd à gérer, cette façon de faire peut vous faciliter la tâche. |
| ← (précédent) D.2 Les bases de la programmation graphique : fenêtre dynamique |
| D.4 Evènements sur les cases à cocher → |
| Accueil ↔ S O M M A I R E |
D.3 Evènements sur boutons simples |