Pour toute suggestion : webmaster@debutantprogjava.com
D.4 Evènements sur des cases à cocher et boutons radio
D.4.1 : Les cases à cocher.
Exemples : case1 : case2 : case3 :
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' espacedu 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 cas à 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 non. 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 actionPerforme().
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 une 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 triate 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.
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é.
D.4.1 : Les boutons radio.
Exemples : Radio 1 : Radio 2 : Radio 3 :
Avant toute chose, sachez que le clic sur un bouton radio peut se réaliser de 2 façons différentes :
D' abord la façon classique : avec la souris, on clique sur le bouton radio.
Une autre façon consiste à sélectionner le bouton radio 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 radio 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(). Mais à la différence d' une case à cocher, les 2 évènements ne se produisent pas toujours
simultanément.
Imaginons 2 boutons radio radio1 et radio2 appartenant au même groupe de boutons. Même groupe signifie qu'un seul bouton du groupe peut être
sélectionné. Un seul à la fois.
Le clic sur radio1 est un évènement qui peut être traité par les 2 méthodes actionPerformed() et itemStateChanged(). Et ce, quelque soit l'état
de radio1. Etat sélectionné : radio1 ou état non sélectionné : radio1
En même temps, si le bouton sélectionné avant le clic sur radio1 était radio2, alors, il se produit forcément un autre évènement qui est la
non-sélection du bouton radio2. Cet évènement peut être traité par la méthode istemStateChanged().
Autrement dit, si aucun des 2 boutons n'était sélectionné avant le clic sur radio1, seul l'action sur radio1 est un évènement. Pas d'évènement
sur radio2. Forcément, puisqu'il ne s'y passe rien.
Trève d' explications. Allons-y pour les exemples.
Exemple 6 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame implements ActionListener
6. {
7. private JRadioButton radio1, radio2; private JButton bouton;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(new Color(208, 208, 255));
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15.
16. ButtonGroup groupeDeBoutons = new ButtonGroup();
17.
18. radio1 = new JRadioButton("RADIO 1");
19. groupeDeBoutons.add(radio1);
20. c.add(radio1);
21.
22. radio2 = new JRadioButton("RADIO 2");
23. groupeDeBoutons.add(radio2);
24. c.add(radio2);
25.
26. setLocationRelativeTo(this.getParent());
27.
28. radio1.addActionListener(this);
29. radio2.addActionListener(this);
30.
31. setDefaultCloseOperation(3);
32. }
33.
34.
34. public void actionPerformed(ActionEvent a)
35. {
36. Object source = a.getSource();
37.
38. if(source == radio1)
39. System.out.println("Action sur RADIO 1");
40. else
41. System.out.println("Action sur RADIO 2");
42. }
43. }
44.
45. public class TesterClicRadio
46. {
47. public static void main(String [] args)
48. {
49. Fenetre f = new Fenetre();
50. f.setVisible(true);
51. }
52. }
Compilez puis exécutez ce programme. Il sera affiché :
Une fenêtre graphique contenant 2 boutons appelés : RADIO 1 et RADIO 2. Cliquez sur RADIO 1, il sera affiché : Action sur RADIO 1. Cliquez sur
RADIO 2, il sera affiché RADIO 2.
Explications :
Un bouton radio n'a de sens que s'il n'est pas unique. Sinon, une case à cocher est à préférer. Et s'il y a plus d'un bouton radio, il est normal
qu'il appartienne à un groupe de boutons de sorte que la sélection d'un bouton radio désactive le bouton préalablement sélectionné. D'où
l'intérêt de créer un objet ButtonGroup (ligne 16).
Ligne 18 : on crée un bouton radio appelé RADIO 1. On l' ajoute au groupe(ligne 19). Puis on l'ajoute au conteneur c (ligne 20).
Même chose pour radio2 : lignes 22 à 24.
Ici, c'est l'objet Fenetre qui est écouteur puisque c'est sa classe qui implément l'interface ActionListener (ligne 5). C'est pourquoi la méthode
actionPerformed() est redéfinie dans la classe Fenetre. Lignes 28 : on associe l'objet écouteur (this) à l'objet raiod1. Même chose pour
l'objet radio2 en ligne 28
Dans la méthode actionPerforme(). La méthode getSource(), comme vous le savez déjà, retourne toujours un objet de type Object. Donc, tout objet,
quelque soit sa classe, peut avoir pour référence, la variable source. Lignes 38 à 41 : Si cet objet est radio1, afficher l'expression : action
sur RADIO 1. Sinon, afficher l'expression : action sur RADIO 2.
Exemple 7 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame implements ItemListener
6. {
7. private JRadioButton radio1, radio2; private JButton bouton;
8. public Fenetre()
9. {
10. setTitle("Une fenetre dynamique");
11. Container c = getContentPane();
12. c.setBackground(new Color(208, 208, 255));
13. setSize(500, 300);
14. c.setLayout(new FlowLayout());
15.
16. ButtonGroup groupeDeBoutons = new ButtonGroup();
17.
18. radio1 = new JRadioButton("RADIO 1");
19. groupeDeBoutons.add(radio1);
20. c.add(radio1);
21.
22. radio2 = new JRadioButton("RADIO 2");
23. groupeDeBoutons.add(radio2);
24. c.add(radio2);
25.
26. setLocationRelativeTo(this.getParent());
27.
28. radio1.addItemListener(this);
29. radio2.addItemListener(this);
30.
31. setDefaultCloseOperation(3);
32. }
33.
34.
34. public void itemStateChanged(ItemEvent i)
35. {
36. Object source = i.getSource();
37.
38. if(source == radio1)
39. System.out.println("Action sur RADIO 1");
40. else
41. System.out.println("Action sur RADIO 2");
42. }
43. }
44.
45. public class TesterClicRadio2
46. {
47. public static void main(String [] args)
48. {
49. Fenetre f = new Fenetre();
50. f.setVisible(true);
51. }
52. }
Compilez puis exécutez ce programme. Il sera affiché :
Une fenêtre graphique contenant 2 boutons appelés : RADIO 1 et RADIO 2. Aucun des 2 boutons n'est sélectionné. Cliquez sur RADIO 1, il sera
affiché : Action sur RADIO 1. Cliquez sur RADIO 2, il sera affiché Action sur RADIO 1 et sur la ligne suivante, il sera affiché Action sur Radio2
Explications :
Souvenez-vous de ce que je vous ai dit sur l'action sur un bouton radio.
Le clic sur radio1 est un évènement qui peut être traité par les 2 méthodes actionPerformed() et itemStateChanged(). Et ce, quelque soit l'état
de radio1. Etat sélectionné : radio1 ou état non sélectionné : radio1
En même temps, si le bouton sélectionné avant le clic sur radio1 était radio2, alors, il se produit forcément un autre évènement qui est la
non-sélection du bouton radio2. Cet évènement peut être traité par la méthode istemStateChanged().
Autrement dit, si aucun des 2 boutons n'était sélectionné avant le clic sur radio1, seul l'action sur radio1 est un évènement. Pas d'évènement
sur radio2. Forcément, puisqu'il ne s'y passe rien.
J'ai utilisé cette fois, l'interface ItemListener. Au début, pas de bouton sélectionné. Donc, l'action sur radio1 conduit à un seul évènement.
C'est pourquoi on voit s'afficher seulement Action sur RADIO 1. Mais en cliquant sur le bouton radio2, on a 2 évènements qui se produisent.
L' un qui est d'abord la non sélection de radio1. C'est pourquoi on voit s'afficher la phrase : Action sur RADIO 1 Puis l'autre évènement
qui est la sélection de radio2. C' est pourquoi en ligne suivante, on voit s'afficher : Action sur RADIO 2
D'où le conseil suivant :
Lorsque vous traitez un évènement survenu lors du clic sur un bouton radio, préférez la méthode actionPerformed(). Dans les logiciels de commerce,
vous avez dû le remarquer, on ne traite (presque) jamais l' évènement que constitue la non sélection d'un bouton radio. L'utilisateur d'un
logiciel clique sur un bouton radio et il sait que ce qui se produit est forcément la conséquence de son choix et pas du tout la non dé-sélection
d'un bouton qu'il n'a même pas (ou plus) regardé en cliquant.
De manière générale toutefois, on préfère laisser à l'utilisateur du logiciel le temps de sélectionner un bouton radio. Et c'est le clic sur un
bouton simple qui validera son choix. C'est plus prudent. Comme dans l'exemple ci-dessous.
Compilez puis exécutez ce programme. Il sera affiché :
Une fenêtre graphique contenant 2 boutons radio appelés RADIO 1 et RADIO 2. En plus, un bouton simple appelé BOUTON DE VALIDATION.
Cliquez sur l'un ou l'autre des boutons. Il ne se passe rien.
Le clic d'un bouton désactive l'autre si ce dernier était préselectionné.
Le clic sur le bouton de validation donne l'état des 2 boutons : sélectionné ou non sélectionné.
Explications :
Le clic sur un bouton Radio ne donne rien parce que aucun des boutons n'est associé à un objet écouteur. Par contre, le clic sur le bouton conduit
à l'éxécution de la méthode actionPerformed(). Normal, le bouton simple est associé à un objet écouteur. Cet objet est la fenêtre elle-même.
Regardez ligne 30 : this représente la fenêtre puisque c'est sa classe qui implémente l'interface ActionListener qui contient le méthode
actionPerformed().
J'ai reçu un message d'une personne me demandant pourquoi affiche-t-on des choses sur la fenêtre console, alors qu'on est en programmation
graphique? ... Pourquoi ne pas afficher directement sur la fenêtre graphique.
Réponse :
Pour l'instant, nous apprenons en mettre en oeuvre la programmation évènementielle à travers divers composants graphiques. Ce n'est pas grave si
on affiche encore en fenêtre console. Mais à partir du prochain chapitre, nous allons commencer à afficher sur la fenêtre graphique. cela dit,
rassurez-vous, nous aurons au moins un chapitre consacré aux véritables exercices corrigés en programmation graphique. Dans ce cas, tout sera sur
la fenêtre graphique.
Débutants en Java -Débutants en programmation graphique