| ← (précédent)D.11 Exercices corrigés (1) |
| D.13 Evènements sur les menus → |
| Accueil ↔ S O M M A I R E |
D.12 Exercices corrigés 2 |
|
EXERCICE 1 Ecrire un programme qui permet d'afficher une fenêtre sur laquelle on voit affiché le nombre de clics effectués sur la fenêtre. |
CORRECTION EXERCICE 1
1. import javax.swing.*; import java.awt.event.*;
2. import java.awt.*; import javax.swing.event.*;
3.
4. class Fenetre extends JFrame implements MouseListener
5. {
6. private JLabel etiket; private static int clics;
7.
8. public Fenetre()
9. {
10. setTitle("Nombre de clics sur fenetre");
11. setSize(400, 150);
12. Container c = getContentPane();
13. c.setLayout( new FlowLayout() );
14. etiket = new JLabel();
15. c.add(etiket);
16. addMouseListener(this);
17. setDefaultCloseOperation(3);
18. }
19.
20. public void mouseClicked(MouseEvent m)
21. {
22. clics++;
23. etiket.setText("Nombre de clics = " + clics);
24. }
25.
26. public void mousePressed(MouseEvent m) {}
27. public void mouseReleased(MouseEvent m) {}
28. public void mouseEntered(MouseEvent m) {}
29. public void mouseExited(MouseEvent m) {}
30. }
31.
32. public class TesterNombreClics
33. {
34. public static void main(String [] args)
35. {
36. Fenetre f = new Fenetre();
37. f.setVisible(true);
38. }
39. }
|
|
Explications La variable clics est déclarée static pour pouvoir incrémenter le compteur. L'interface qui gère les clics est MouseListener et c'est la fenêtre qui est l'objet écouteur. La méthode setText() appliquée à l'objet etiket permet d'afficher le texte passé en paramètre de la méthode. Les autres méthodes de l'interface MouseListener sont redéfinies à vide (lignes 26 à 29). Pas très compliqué. |
|
EXERCICE 2 Ecrire un programme qui permet d'afficher une fenêtre sur laquelle se trouve une boite combo. La boite combo contient une liste de 5 noms correspondants à 5 couleurs différentes. Si on choisit un de ces noms, la fenêtre prend la couleur correspondante. |
CORRECTION EXERCICE 2
1. import javax.swing.*; import java.awt.event.*;
2. import java.awt.*; import javax.swing.event.*;
3.
4. class Fenetre extends JFrame implements ItemListener
5. {
6. private String [] couleurs = {"rouge", "vert", "bleu", "gris", "jaune"};
7. private JComboBox boite; Container c;
8.
9. public Fenetre()
9. {
10. setTitle("Changement dynamique des couleurs");
11. setSize(300, 300);
12. c = getContentPane();
13. c.setLayout( new FlowLayout() );
14. boite = new JComboBox(couleurs);
15. c.add(boite);
16. boite.addItemListener(this);
17. setDefaultCloseOperation(3);
18. }
19.
20. public void itemStateChanged(ItemEvent i)
21. {
22. int choix = boite.getSelectedIndex();
23.
24. switch(choix)
25. {
26. case 0:
27. c.setBackground(new Color(255, 0, 0) );
28. break;
29.
30. case 1:
31. c.setBackground(new Color(0, 255, 0) );
32. break;
33.
34. case 2 :
35. c.setBackground(new Color(0, 0, 255) );
36. break;
37.
38. case 3:
39. c.setBackground(new Color(208, 208, 208) );
40. break;
41.
42. default:
43. c.setBackground(new Color(255, 255, 0) );
44. break;
45. }
46. }
47. }
48.
49. public class ChangementDeCouleur
50. {
51. public static void main(String [] args)
52. {
53. Fenetre f = new Fenetre();
54. f.setVisible(true);
55. }
56. }
|
|
Explications La méthode getSelectedIndex() permet d'obtenir la position de l'élément sélectionné dans la boite combo. Le conteneur c est déclaré (ligne 7) en dehors de toute fonction. Le but est de pouvoir utiliser cette variable dans la méthode itemStateChanged(). Souvenez-vous : c'est le conteneur qu'on colore et non la fenêtre elle même. Cette coloration se fait grâce à la méthode setBackground(), laquelle requiert un argument de type Color. Cet objet de type Color est construit grâce à un constructeur qui requiert 3 arguments de type int. Le premier étant la quantité de rouge. Le deuxième étant la quantité de vert et le troisième étant la quantité de bleu. On peut gérer l'action sur une boite combo soit avec la méthode actionPerformed() de l'interface ActionListener ou par la méthode itemStateChanged() de l'interface ItemListener. Ici, j'ai choisi la 2ème. c pa kompliké ! |
|
EXERCICE 3 : Convertisseur de monnaie. Ecrire un programme qui permet d'afficher une fenêtre sur laquelle se trouvent 2 champs. Le premier est précédé d'une étiquette Euros et le deuxième d'une étiquette Francs. Lorsque l'utilisateur entre un nombre dans le premier champ, sa conversion en Francs apparaît simultanément dans le deuxième champ. Le deuxième champ est non éditable. Autrement dit, non modifiable. Attention ! ! !... prévoir le cas où l'utilisateur saisie un caractère qui n'est pas un chiffre. |
CORRECTION EXERCICE 3
1. import javax.swing.*; import java.awt.event.*;
2. import java.awt.*; import javax.swing.event.*;
3.
4. class Fenetre extends JFrame implements DocumentListener
5. {
6. private JLabel etiket1, etiket2;
7. private JTextField champ1, champ2;
8.
9. public Fenetre()
10. {
11. setTitle("Convertisseur de monnaies");
12. setSize(500, 100);
13. Container c = getContentPane();
14. c.setLayout( new FlowLayout() );
15. etiket1 = new JLabel("Euros");
16. c.add(etiket1);
17. champ1 = new JTextField(15);
18. c.add(champ1);
19. etiket2 = new JLabel("Francs");
20. c.add(etiket2);
21. champ2 = new JTextField(15);
22. champ2.setEditable(false);
23. c.add(champ2);
24. champ1.getDocument().addDocumentListener(this);
25. setDefaultCloseOperation(3);
26. }
27.
28. public boolean estUnNombre(String chaine)
29. {
30. try
31. {
32. Double.parseDouble(chaine);
33. return true;
33. }
34. catch (NumberFormatException e)
35. {
36. return false;
37. }
38. }
39.
40. public void insertUpdate(DocumentEvent d)
41. {
42. String texte = champ1.getText();
43.
44. if( estUnNombre(texte) )
45. {
46. double euros = Double.parseDouble(texte);
47. double francs = euros * 6.56;
48. String conversion = "" + francs;
49. champ2.setText(conversion);
50. }
51. else
52. {
53. JOptionPane.showMessageDialog(this, "Ce caractere n'est pas un nombre");
54. }
55.
56. }
57.
58. public void removeUpdate(DocumentEvent d)
59. {
60. String texte = champ1.getText();
61.
62. double euros = Double.parseDouble(texte);
63.
46. double francs = euros * 6.56;
64.
65. String conversion = "" + francs;
66.
67. champ2.setText(conversion);
68. }
69.
70. public void changedUpdate(DocumentEvent d){}
71.
72. }
73.
74. public class ConvertisseurDeMonnaie
75. {
76. public static void main(String [] args)
77. {
78. Fenetre f = new Fenetre();
79. f.setVisible(true);
80. }
81. }
|
|
Tapez un nombre dans le champ consacré aux Euros. Immédiatement, la conversion en francs se fait sur le deuxième champ. Explications De la ligne 11 à la ligne 23 : création des champs champ1 et champ2 et des étiquettes etiket1 et etiket2. Ligne 22 : le champ2 est non modifiable. Ligne 24 : on associe au champ1 un objet écouteur. Normal, c'est l'action sur ce champ qui entrainera la réaction voulue dans l'autre champ. Lignes 28 à 38 : je crée une méthode qui permet de détecter si ce qui est saisi dans le champ1 est un nombre. J'appelle cette méthode estUnNombre. Cette méthode requiert un argument de type String. Parce que la valmeur d'un champ de texte, obtenue par la méthode getTex() est de type String. Ligne 32 : j'utilise la méthode parseDouble() de la classe Double pour transformer un String en double. Il est clair qu'une valeur de type String ne peut être transformé en double (nombre réel) que si tous les caractères du String sont des chiffres. Dans le cas contraire, une erreur se produit et le programme s'interrompt. C'est pour éviter que cette erreur se produise qu'on utilise le gestionnaire d'exception try...catch. J' essaye (try) alors de transformer ce String en double (ligne 32) et si c'est bon, la valeur retournée est true. Dans le cas contraire, on capte (catch) l'erreur de type Format d'un Nombre (évitant ainsi l'interruption du programme) puis on retourne false puisque la valeur de type String n'a donc pas pu être tranformé en nombre. Dans la prochaine version du site java (dans www.debutantprog.com), il y aura un chapitre sur la gestion des exceptions et vous comprendrez mieux ce que je viens d'expliquer. Autre chose, nous verrons la classe Double dans le prochain site. Cette classe permet de résoudre certains problèmes. J'aurais ausi pu utiliser la méthode parseFloat() de la classe Float. Mais un nombre réel dont on ne connait par la valeur à l'avance, on considere que c'est du double. Tout comme un nombre entier dont on ne connait pas la valeur à l'avance est considéré comme du int Notez cette différence D majuscule et d miniscule. Double est le nom d'une classe alors que double est le type d'une variable. Pour traiter l'évènement consistant à taper du texte dans un champ de texte, on utilise l'interface DocumentListener. Mais avant, il faut transformer le contenu du champ en objet Document. C'est ce qu'on fait en ligne 24 en écrivant champ1.getDocument(). C'est cet objet qui est en fait associé à la objet écouteur (ici, la fenêtre, this) par la méthode addDocumentListener(). Cette interface possède 3 méthodes : insertUpdate(), remodeUpdate() et changedUpdate() La méthode changedUpdate() n'est pas utilisée ici. D'ailleurs, elle n'est jamais utilisée sur les champs de texte. Elle sera utilisée avec d'autres objets. Elle est donc forcément redéfinie à vide ici. Dans la méthode insertUpdate(), ligne 42 : je mets le contenu du champ1 (par champ1.getText() ) dans la variable texte. Ligne 44 : Si ce contenu est un nombre, alors (ligne 46 ), sa transformation effective en variable double (Double.parseDouble(texte) est mise dans la variable euros. La variable euros (ligne 45) contient la valeur du double multiplié par 6.56 conversion des euros en francs. Je dois donc mettre cette valeur en francs dans le champ2. Or, la méthode setText(à qui permet de donner une valeur à un champ de texte requiert un argument de type String. Je ne peux donc pas écrire champ2.setText(francs);. Il faut transformer ce contenu de type double en type String. String conversion = "" (chaine vide, zéroi caractère) + francs. Comme on l'a déjà vu dans un chapitre, string + double donne toujours String. Ligne 49 : conversion est donc mise dans le champ 2. Dans le cas où la valeur du champ n'est pas un nombre (ligne 51 : else), apparition d'une fenêtre de dialogue se type information qui informe justement à l'utilisateur du programme que le caractère qu'on vient de saisir n'est pas un nombre. On clique alors sur Ok. Puis on efface sa saisie. Dans le méthode removeUpdate(), pas de structure conditionnelle. Cela ne sert à rien. On met les mêmes instructions que dans insertUpdate(). Seulement les instructions qui correspondent à la situation où la valeur saisie est vraiment un nombre. Dès que le premier caractère qui n'est pas un nombre est saisi, la conversion dans l'autre champ s'arrête. Il suufit d'effacer ce caractère pour que tout redevient normal. |
|
EXERCICE 4 : Ecrire un programme qui permet d'afficher une fenêtre disposant de 3 boutons placés dans un panneau, disposé verticalement sur le côté gauche de la fenêtre. Au centre de la fenêtre, doit apparaître une phrase au moment où l'on clique sur un bouton. La phrase indique quel bouton a été cliqué. Faites en sorte qu'un bip soit entendu chaque fois qu'on clique sur un bouton. Pensez à la méthode beep() de la classe Toolkit.) |
CORRECTION EXERCICE 4
1. import javax.swing.*; import java.awt.event.*;
2. import java.awt.*; import javax.swing.event.*;
3.
4. class Fenetre extends JFrame implements ActionListener
5. {
6. private JButton b1, b2, b3;
7. private JPanel panneau; private JTextField champ;
8.
9. public Fenetre()
10. {
11. setTitle("Tester origine des boutons");
12. setSize(250, 150);
13. Container c = getContentPane();
14.
15. panneau = new JPanel();
16. c.add(panneau, "West");
17. champ = new JTextField();
18. c.add(champ);
19.
20. Box boxVertical = Box.createVerticalBox();
21. panneau.add(boxVertical);
22.
23. b1 = new JButton("bouton 1");
24. boxVertical.add(b1);
25. b1.addActionListener(this);
26.
27. b2 = new JButton("bouton 2");
28. boxVertical.add(b2);
29. b2.addActionListener(this);
30.
31. b3 = new JButton("bouton 3");
32. boxVertical.add(b3);
33. b3.addActionListener(this);
34.
35. setLocationRelativeTo(this.getParent());
36. setDefaultCloseOperation(3);
37.
38. }
39.
40. public void actionPerformed(ActionEvent a)
41. {
42. if(a.getSource() == b1)
43. {
44. champ.setText("clic sur bouton 1");
45. }
46. else if(a.getSource() == b2)
47. {
48. champ.setText("clic sur bouton 2");
49. }
50. else
51. {
52. champ.setText("clic sur bouton 3");
53. }
54. Toolkit.getDefaultToolkit().beep();
55. }
56. }
57.
58. public class TesterOrigineBoutons
59. {
60. public static void main(String [] ergs)
61. {
62. JFrame f = new Fenetre();
63. f.setVisible(true);
64. }
65. }
|
|
Ligne 15 : création d'un conteneur de type JPanel. Ligne 16 : Ce panneau est ajouté à gauche de la fenêtre. Ligne 17 : Création d'un champ de
texte. Puis en ligne 18 : on ajoute ce champ dans le conteneur c. Le conteneur c dispose les composants façon BorderLayout. Le panneau est donc à l'ouest et l'autre composant occupe le reste de la fenêtre. Ligne 20 : on crée un box vertical, qu'on ajoute au panneau en ligne 21. Ligne 23 : on crée un bouton qu'on ajoute au box vertical(en ligne 24) Puis on associe à ce bouton, un objet écouteur qui est la fenêtre elle-même (this). Même topo pour les 2 autres boutons. Dans la méthode actionPerformed(), on dit que si la source de l'évènement est l'objet bouton b1, alors, le texte du champ doit être clic sur bouton 1 Sinon, si la source est b2, alors, le texte du champ est clic sur bouton 2 Autrement, le texte du champ est clic sur bouton 3 La ligne 54 : pour faire sonner l'action sur un bouton, on applique à la méthode beep(), un objet de type Toolkit. Cet objet ne s'obtient pas par instanciation classique : Toolkit tk = new Toolkit() Parce que la classe Toolkit est une classe abstraite. On obtient un objet de type Toolkit en utilisant la méthode (static) getDefaultToolkit() de la classe Toolkit. On aurait pu écrire : Toolkit tk = Toolkit.getDefaultToolkit(); Puis faire tk.beep(); Ce qui correspond exactement à : Toolkit.getDefaultToolkit().beep(); |
|
EXERCICE 5 : Ecrire un programme qui permet d'afficher une fenêtre disposant d'un bouton. Quand on clique sur le bouton, on ferme la fenêtre et le programme s'arrête. indication : méthode exit() de la classe System |
CORRECTION EXERCICE 5
1. import javax.swing.*; import java.awt.event.*;
2. import java.awt.*; import javax.swing.event.*;
3.
4. class Fenetre extends JFrame implements ActionListener
5. {
6. JButton bouton;
7. public Fenetre()
8. {
9. setTitle("arrête programme");
10. setSize(200, 200);
11. Container c = getContentPane();
12. bouton = new JButton("Fermer");
13. c.add(bouton, "South");
14. bouton.addActionListener(this);
15. setLocationRelativeTo(this.getParent());
16. setDefaultCloseOperation(3);
17. }
18.
19. public void actionPerformed(ActionEvent a)
20. {
21. System.exit(0);
22. }
23.
24. }
25.
26. public class BoutonArretProgramme
27. {
28. public static void main(String [] args)
29. {
30. JFrame f = new Fenetre();
31. f.setVisible(true);
32. }
33. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Une fenêtre avec un bouton "Fermer". Cliquez sur ce bouton et la fenêtre se ferme et le programme s'arrête. La méthode exit() de la classe System permet d'arrêter le programme. Elle requiert un argument de type int. Ici, on utilise la valeur zéro. Je ne vais pas entrer dans les détails sur les diverses valeurs possibles. Mais si vous voulez arrêter le programme, utilisez la valeur 0. Dans le site www.debutantprog.com je parlerai de la classe System. Ainsi, on comprendra mieux aussi la méthode System.out.println(). Si vous voulez fermer la fenêtre sans arrêter le programme, setVisible(false) aurait suffit. |
|
EXERCICE 6 : Ecrire un programme qui permet d'afficher une fenêtre disposant de 2 boutons radio (appelés adulte et enfant) disposés au nord de la fenêtre. Si on clique sur le bouton adulte, il apparaît au bas de la fenêtre, 2 boutons simples appelés travailleur? et chômeur? Si on clique sur le bouton radio enfant, il apparaît au bas de la fenêtre, 2 boutons simples appelés scolarisé? et non scolarisé? |
CORRECTION EXERCICE 6
1. import javax.swing.*; import java.awt.event.*;
2. import java.awt.*; import javax.swing.event.*;
3.
4. class Fenetre extends JFrame implements ActionListener
5. {
6. JButton bouton1, bouton2, bouton3, bouton4;
7. JRadioButton b1, b2;
8. JPanel p1, p2;
9.
10. public Fenetre()
11. {
12. setTitle("arrête programme");
13. setSize(400, 200);
14. Container c = getContentPane();
15.
16. p1 = new JPanel();
17. p1.setBackground(new Color(0, 190, 0));
18. c.add(p1, "North");
19.
20. p2 = new JPanel();
21. p2.setBackground(new Color(190, 0, 0));
22. c.add(p2, "South");
23.
24. ButtonGroup gr = new ButtonGroup();
25.
26. b1 = new JRadioButton("Adulte");
27. b1.addActionListener(this);
28. gr.add(b1);
29. p1.add(b1);
30.
31. b2 = new JRadioButton("Enfant");
32. b2.addActionListener(this);
33. gr.add(b2);
34. p1.add(b2);
35.
36. bouton1 = new JButton("Travailleur ?");
37. p2.add(bouton1);
38. bouton1.setVisible(false);
39.
40. bouton2 = new JButton("chômeur ?");
41. p2.add(bouton2);
42. bouton2.setVisible(false);
43.
44. bouton3 = new JButton("Scolarisé ?");
45. p2.add(bouton3);
46. bouton3.setVisible(false);
47.
48. bouton4 = new JButton("Non Scolarisé ?");
49. p2.add(bouton4);
50. bouton4.setVisible(false);
51.
52. setLocationRelativeTo(this.getParent());
53. setDefaultCloseOperation(3);
54.
55. }
56.
57. public void actionPerformed(ActionEvent a)
58. {
59. if(a.getSource() == b1)
60. {
61. bouton1.setVisible(true);
62. bouton2.setVisible(true);
63. bouton3.setVisible(false);
64. bouton4.setVisible(false);
65. p2.validate();
66. }
67. else
68. {
69. bouton1.setVisible(false);
70. bouton2.setVisible(false);
71. bouton3.setVisible(true);
72. bouton4.setVisible(true);
73. p2.validate();
74. }
75. }
76. }
77. public class CreationDeBoutons
78. {
79. public static void main(String [] args)
80. {
81. JFrame f = new Fenetre();
82. f.setVisible(true);
83 }
84. }
|
|
Ligne 16 : création d'un panneau. Ligne 17 : attribution d'une couleur à ce panneau. Ligne 18 : placement de ce panneau au nord de la fenêtre. Lignes 20 à 22 : Même chose pour le panneau 2 situé au sud de la fenêtre. Ligne 24 : création dun groupe dans lequel on met des boutons radio pour le principe de désélection d'un bouton après sélection d'un autre. Ligne 26 : création d'un bouton radio. Ligne 27 : association d'un objet écouteur. Ligne 28 : ajout du bouton radio dans le groupe. Ligne 29 : ajout du bouton radio dans le panneau p1. Lignes 31 à 34 : Même chose pour le bouton radio b2. Ligne 36 : création d'un bouton simple. Ligne 37 : ajout de ce bouton au panneau p2. Ligne 38 : non visibilité du bouton sur le panneau. Lignes 40 à 42 : même chose pour le bouton simple bouton 2 Lignes 44 à 46 : même chose pour le bouton simple bouton 3 Lignes 48 à 50 : même chose pour le bouton simple bouton 4 Dans la méthode actionPerformed(), on dit que si la source de l'évènement est le bouton b1, autrement dit, si on sélectionne ce bouton radio b1, alors, les boutons simples bouton1 et bouton2 sont visibles. Et les boutons bouton3 et bouton4 sont invisibles. Sinon (le cas où c'est plutôt le bouton b2 qui est sélectionné), alors les boutons simples bouton1 et bouton2 sont invisibles. Et les boutons bouton3 et bouton4 sont visibles. Parlons maintenant de l'instruction p2.validate(); Jusqu'ici, les composants graphiques apparaissent au moment de l'affichage de la fenêtre. Ici, les boutons simples apparaissent au cours de l'exécution du programme. En java, lorsque un composant est ajouté ou supprimé à la fenêtre au cours du programme, vous devez forcément ajouté une instruction particulière. Vous appliquez la méthode validate() au conteneur de ce composant ou vous appliquez la méthode revalidate() au composant ajouté ou supprimé. Ici, il y a plusieurs boutons boutons à ajouter ou à supprimer. Il vaut mieux appliquer la méthode validate() au conteneur. Parce que appliquer la méthode revalidate() aux composants ajoutés ou supprimés nous entraine dans 4 instructions. Faut savoir coder court. La méthode validate() ou la méthode revalidate() permet au gestionnaire de mise en forme de recalculer les positions des composants avant de les placer dans la fenêtre. En effet, on ne s'en rend pas compte. Mais le gestionnaire de mise en forme calcule les nombre de composants, la surface qu'ils vont occuper, avant de les placer. |
| ← (précédent)D.11 Exercices corrigés (1) |
| D.13 Evènements sur les menus → |
| Accueil ↔ S O M M A I R E |
D.12 Exercices corrigés 2 |