| ← (précédent) D.3 Evènements sur les boutons simples |
| D.5 Evènements les boutons radio → |
| Accueil ↔ S O M M A I R E |
D.4 Evènements sur les cases à cocher |
|
Avant toute chose, sachez que le clic sur une case à cocher peut se réaliser de 2 façons différentes : D' abord la façon classique : avec la souris, on clique sur la case à cocher. Une autre façon consiste à sélectionner la case à cocher grâce à la touche tabulation (pointillés sur la case), 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 une case à cocher est traitée par la méthode (forcément prédéfinie) actionPerformed(). Ou par la méthode (forcément prédéfinie aussi) itemStateChanged(). La méthode actionPerformed() 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 ActionAdapter. Puisqu'il n'y a qu'une seule méthode à redéfinir. La méthode itemStateChanged() est déclarée : public void itemStateChanged(ItemChanged i) dans l'interface ItemListener. Laquelle ne possède que cette méthode là. Il n'existe donc pas de classe ItemAdapter, puisqu'il n'y aqu'une seule méthode à redéfinir. Ici, nous pouvons créer une réaction de 2 façons différentes. Réaction immédiate après le clic sur la case. Ou alors, on sélectionne d'abord la case. Ensuite, le clic sur un bouton permet une réaction qui tient compte de l'état (sélectionné ou non) de la case. Trève d' explications. Allons-y pour les exemples. |
Exemple 1 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame
6. {
7. private JCheckBox cocher;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(new Color(255, 208, 208));
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15. cocher = new JCheckBox("Case");
16. c.add(cocher);
17. setLocationRelativeTo(this.getParent());
18. cocher.addActionListener(new EcouteurDeCases() );
19. setDefaultCloseOperation(3);
20. }
21.
22. }
23.
24. class EcouteurDeCases implements ActionListener
25. {
26. public void actionPerformed(ActionEvent a)
27. {
28. System.out.println("Vous venez de cliquer sur la case");
29. }
30. }
31.
32.
33. public class TesterClicCase
34. {
35. public static void main(String [] args)
36. {
37. Fenetre f = new Fenetre();
38. f.setVisible(true);
39. }
40. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Une fenêtre graphique sur laquelle on verra une case à cocher dont le nom associé est : Case. Cliquez sur le bouton et il sera affiché sur la fenêtre console : Vous venez de cliquer sur la case Explications : ligne 15 : création d'une case à cocher. ligne 16 : ajout de la case dans la fenêtre. ligne 18 : on associe à l'objet source case, l'objet écouteur new EcouteurDeCases(). Et naturellement, le code de la méthode actionPerformed() est exécutée. Essayons la même chose avec l'interface ItemListener |
Exemple 2 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame
6. {
7. private JCheckBox cocher;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(new Color(255, 208, 208));
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15. cocher = new JCheckBox("Case");
16. c.add(cocher);
17. setLocationRelativeTo(this.getParent());
18. cocher.addItemListener(new EcouteurDeCases() );
19. setDefaultCloseOperation(3);
20. }
21.
22. }
23.
24. class EcouteurDeCases implements ItemListener
25. {
26. public void itemStateChanged(ItemEvent a)
27. {
28. System.out.println("Vous venez de cliquer sur la case");
29. }
30. }
31.
32.
33. public class TesterClicCase2
34. {
35. public static void main(String [] args)
36. {
37. Fenetre f = new Fenetre();
38. f.setVisible(true);
39. }
40. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : la même chose que là haut. Normal, c' est la même programme. Avec une petite différence
tout de même. On gère l'évènement clic sur une case à cocher avec la méthode itemStateChanged(). Donc, la classe écouteur doit implémenter cette
fois, l'interface ItemListener. Et la méthode itemStateChanged() doit avoir un argument de la classe ItemEvent.
|
|
Dans les deux exemples ci-dessus, on a eu une réaction aussitôt après le clic sur la case. Que la case soit cochée ou décochée. On peut faire en sorte que la
réaction ait lieu après clic sur un bouton de validation. C'est en général ce qui se passe. Dans un logiciel de commerce, on dispose en général
de plusieurs cases. On prend le temps de cocher ou décocher. Puis le clic sur un bouton permet d'avoir une réaction qui dépend de l' état d'une
ou des cases. Etat coché ou état décoché. Pour éviter une réaction qui se déclenche aussitôt après clic sur la case, il suufit de ne pas associer l'objet écouteur à l'objet case. Mais plutôt associer à l'objet bouton, l'objet écouteur. Et la réaction sera alors décrite dans la méthode actionPerformed(). Exemple suivant |
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 JCheckBox cocher; private JButton bouton;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(new Color(255, 208, 208));
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15. cocher = new JCheckBox("CASE");
16. c.add(cocher);
17. setLocationRelativeTo(this.getParent());
18. bouton = new JButton("VALIDATION");
19. c.add(bouton);
20. bouton.addActionListener(this);
21. setDefaultCloseOperation(3);
22. }
23.
24. public void actionPerformed(ActionEvent a)
25. {
26. if(cocher.isSelected() )
27. {
28. System.out.println("la case est cochée");
29. }
30. else { System.out.println("la case n'est pas cochée"); }
31. }
32. }
33.
34. public class TesterClicCase3
35. {
36. public static void main(String [] args)
37. {
38. Fenetre f = new Fenetre();
39. f.setVisible(true);
40. }
41. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Une fenêtre contenant : une case à cocher appelé CASE, suivi d' un bouton appelé VALIDATION. Cliquez sur le bouton, il sera affiché sur la fenêtre console la phrase : la case n'est pas cochée. Maintenant, cliquez sur la case à cocher. Il ne se passera rien. Normal, Cet objet n'est pas associé à un objet écouteur. Cliquez à nouveau sur le bouton de validation. il sera affiché sur la fenêtre console la phrase : la case est cochée. Explications : L' obejt écouteur est la fenêtre. C' est pourquoi la classe Fenetre implémente l'interface ActionListener. L' objet Fenetre est donc associé à l'objet bouton grâce à la méthode addActionListener() en ligne 20. L' argument de la méthode est forcément this puisqu'il s'agit de l'objet Fenetre sur laquelle se trouve le bouton. Dans la définition de la méthode actionPerformed(), nous découvrons une nouvelle méthode : isSelected() . Cette méthode appartient à la classe prédéfinie AbstractButton, une classe mère de JcheckBox. Cette méthode est de type void. Elle renvoie true lorsque la case à cocher est sélectionnée. Et false dans le cas contraire. Ligne 26 : si la la case à cocher appelée cocher est sélectionnée, ligne 28 : écrire dans la fenêtre console : la case est cochée. Ligne 30 : dans le cas contraire, écrire plutôt : la case n'est pas cochée. |
|
Petite astuce : Dans la méthode qui permet de gérer un évènement, on fait très souvent appel à une méthode qu'on applique à un objet qui est le composant qu'on trouve dans la fenêtre. Je pense à la méthode getSource() : Exemple : if(e.getSource() == bouton1) La méthode getActionCommand() : Exemple : if(e.getActionCommand() == "BOUTON 1" Ou comme ci-dessus, la méthode isSelected(). Exemple : if(cocher.isSelected() ) Or, il se trouve que parfois, on ne peut pas faire en sorte que la classe servant à créer la fenêtre graphique soit aussi écouteur du composant. Autrement dit, la classe servant à créer la fenêtre ne doit pas implémenter l'interface contenant la méthode permettant de gérer l'évènement. Donc, la classe qui ecoute, autrement dit, la classe qui implémente l'interface en question, doit être à part. Parfois même, dans un fichier indépendant. Dans ce cas, une difficulté apparaît. Puisque les champs de la classe servant à créer la fenêtre doivent être déclarés en private (vivement conseillé en POO), comment manipuler dans une classe, un objet déclaré en private dans une autre classe ? Exemple : Comment manipuler l'objet de type JCheckBox, cocher, dans une classe qui n'est pas la classe Fenetre ? ... Cet objet qui est déclaré en private ?... L'une des solutions serait de déclarer cocher en mode public. Très déconseillé en POO. On pourrait aussi déclarer l'objet en protected. Mais dans ce cas, la classe qui écoute doit dériver de la classe Fenetre. Ainsi, on peut manipuler les champs protégés d'une classe dans sa classe dérivée. Mais là, ça n'a pas d'intérêt. On crée une classe dérivée de Fenetre pour manipuler des objets de type Fenetre, mais étendus. Alors, la solution serait de doter la classe ecouteur d'un constructeur qui aura pour argument, un objet ayant le même type que le champ privé de la classe Fenetre. Voyons un exemple : |
Exemple 4 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame
6. {
7. private JCheckBox cocher; private JButton bouton;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(new Color(208, 255, 255));
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15. cocher = new JCheckBox("CASE");
16. c.add(cocher);
17. setLocationRelativeTo(this.getParent());
18. bouton = new JButton("VALIDATION");
19. c.add(bouton);
20. EcouteurDeBoutons eb = new EcouteurDeBoutons(cocher);
21. bouton.addActionListener(eb);
22. setDefaultCloseOperation(3);
23. }
24. }
25.
26.
27. class EcouteurDeBoutons implements ActionListener
26. {
27. private JCheckBox cocher;
28.
29. public EcouteurDeBoutons(JCheckBox cocher)
30. {
31. this.cocher = cocher;
32. }
33.
34. public void actionPerformed(ActionEvent a)
35. {
36. if(cocher.isSelected() )
37. {
38. System.out.println("la case est cochée");
39. }
40. else
41. {
42. System.out.println("la case n'est pas cochée");
43. }
44. }
45. }
46.
47.
48. public class TesterClicCase4
49. {
50. public static void main(String [] args)
51. {
52. Fenetre f = new Fenetre();
53. f.setVisible(true);
54. }
55. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : La même chose que dans l'exemple précédent. Les mêmes affichages en cliquant sur la case ou sur le bouton. Explications : Afin de comprendre, quelques rappels : La signature d'une méthode, c'est le type retour de la méthode, le nom de la méthode, les parenthèses à l'intérieur desquelles se trouvent les types des arguments. Exemple : la méthode actionPerformed() de l'interface ActionListener : void actionPerformed(ActionEvent) Lorsqu'on redéfinit une méthode, on ne change pas sa signature. Seule sa définiton change. D'où le terme redéfinition. Une méthode est définie avec des arguments. Ces paramètres n'existent que de nom. Dans la mémoire, physiquement, ils sont inexistants. En utilisant la méthode, on lui passe des paramètres réels dans les parenthèses. Le principe, c'est de créer dans la classe EcouteurDeBouton, une variable de type JCheckBox, puis de l'utiliser dans la définition de la méthode qui traite l'évènement. EN l'occurence, la méthode actionPerformed(). Mais ce n'est pas suffisant. Si on appelle la méthode actionPerformed() par le biais de la méthode addActionListener(), c' est la variable cocher de la classe EcouteurDeBoutons qui est utilisée. Et l'objet qui lui correspond n'existe même pas. C' est la référence à un objet de type JCheckBox qui existe. Et on ne peut même pas ajouter un argument à la méthode actionPerformed(). On ne peut pas changer sa signature. D'où l'intérêt du contructeur de la classe EcouteurDeBouton. Ainsi, lorsqu'on crée l'objet new EcouteurDeBoutons(), c'est à dire en utilisant la méthode contructeur, on lui passe la variable cocher de la classe Fenetre. Cette variable remplace alors celle de la méthode actionPerformed() créée dans la classe EcouteurDeBouton. Ce qui est vrai pour un seul composant (ici, la case à cocher), l'est aussi pour plusieurs composants. |
Exemple 5 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame
6. {
7. private JCheckBox cocher1, cocher2; private JButton bouton;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(new Color(208, 255, 255));
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15. cocher1 = new JCheckBox("CASE 1");
16. c.add(cocher1);
17. cocher2 = new JCheckBox("CASE 2");
18. c.add(cocher2);
19. setLocationRelativeTo(this.getParent());
20. bouton = new JButton("VALIDATION");
21. c.add(bouton);
22. EcouteurDeBoutons eb = new EcouteurDeBoutons(cocher1, cocher2);
23. bouton.addActionListener(eb);
24. setDefaultCloseOperation(3);
25. }
26. }
27.
28.
29. class EcouteurDeBoutons implements ActionListener
30. {
31. private JCheckBox cocher1, cocher2;
32.
33. public EcouteurDeBoutons(JCheckBox cocher1, JCheckBox cocher2)
34. {
35. this.cocher1 = cocher1;
36. this.cocher2 = cocher2;
37. }
38.
39. public actionPerformed(ActionEvent a)
40. {
41. String situation1, situation2;
42. if(cocher1.isSelected() )
43. situation1 = "CASE 1 cochée";
44. else
45. situation1 = "CASE 1 non cochée";
46.
47. if(cocher2.isSelected() )
48. situation2 = "CASE 2 cochée";
49. else
50. situation2 = "CASE 2 non cochée";
51.
52. System.out.println("Etat des cases : " + situation1 + " et " + situation2);
53. }
54.
55. }
56.
57. public void class TesterClicCase5
58. {
59. public static void main(String [] args)
60. {
61. Fenetre f = new Fenetre();
62. f.setVisible(true);
63. }
64. }
|
|
Même tope qu'à l'exemple précédent. Sauf qu'ici, nous avons manipulé, dans la classe EcouteurDeBoutons, 2 objets JCheckBox au lieu d'un seul.
Pour cette raison, nous avons utilisé dans le contruteur de la classe EcouteurDeBoutons, 2 objets JCheckBox. Pour cette raison, nous avons
contruit l'objet écouteur (eb en ligne 22), avec les 2 objets en paramètres. Vous compilez et vous exécutez, le résultat est celui escompté. |
| ← (précédent) D.3 Evènements sur les boutons simples |
| D.5 Evènements sur les boutons radio → |
| Accueil ↔ S O M M A I R E |
D.4 Evènements sur les cases à cocher |