| ← (précédent) D.1 Les bases de la programmation graphique : fenêtre statique |
| D.3 Evènements sur les boutons simples → |
| Accueil ↔ S O M M A I R E |
D.2 Les bases de la programmation graphique : |
|
Comme je l'ai déjà dit, la programmation graphique est essentiellement basé sur les évènements. L'utilisateur effectue une action (un évènement)
et il s'en suit une réaction (un autre évènement). Par exemple, vous cliquez sur un bouton, une autre page, contenant des informations recherchées
apparait. En java, tout évènement possède une source. C' est à dire l'objet lui ayant donné naissance. Vous cliquez sur une fenêtre, la source est la fenêtre. Vous cliquez sur un bouton, la source est le bouton. Vous cliquez sur case à cocher, l' objet est la case à cocher. Vous allez dans le menu Fichier, vous choisissez un sous-menu tel que enregistrez, la source est le sous-menu enregitrez ou le sous-menu enregistrez sous. Pour traiter un évènement en java, on associe à l' objet source, un autre objet, instancié à partir d'une classe qui implémente une interface particulière. La particularité de cette interface est qu'elle est prédéfinie. Vous ne l'inventez pas. En plus, cette interface possède un ensemble de méthodes dont l'une d'elle permet justement de traiter l' évènement en question. Je sais, Ce n'est pas très clair tout ça. Mais avec un premier exemple, vous aurez le pied à l'étrier. Allons-y ! |
Exemple zéro :
1. import javax.swing.*;
2. import java.awt.*;
3.
4.
5. class Fenetre extends JFrame
6. {
7. public Fenetre()
8. {
9. System.out.println("Quelles dimensions pour votre fenetre ? ");
10. System.out.print("Largeur = "); double largeur = Lire.reelDouble();
11. System.out.println();
12. System.out.print("Hauteur = "); double hauteur = Lire.reelDouble();
13. System.out.println();
14. setBounds(10, 20, 500, 300);
15. setVisible(true);
16. }
17.
18. }
19.
20.
21. public class TesterFenetre
22. {
23. public static void main(String [] args)
24. {
25. Fenetre f = new Fenetre();
26. f.setDefaultCloseOperation(3);
27. }
28. }
|
|
Compilez puis exécutez ce programme. il sera affiché sur la fenêtre console: Quelles dimensions pour votre fenetre ? Largeur =_ Le programme attend que vous donniez une largeur à votre fenêtre. Ceci étant fait, vous appuyez sur la touche entrée. Hauteur = _ Le programme attend que vous donniez une hauteur à votre fenêtre. Ceci étant fait, vous appuyez sur la touche entrée. Puis la fenêtre graphique est affichée. Avant d'entamer la programmation évènementielle proprement dite, j'ai tenu à cet exemple pour vous faire comprendre quelque chose. Dans un véritable programme professionnel, il vaut mieux créer une fenêtre à partir d'une classe dérivée de JFrame. Parce que lorsque vous créez une fenêtre à partir de JFrame, les seules méthodes applicables à cette fenêtre (cet Objet) sont celles de JFrame ou d' une classe ascendante de JFrame. Autrement dit, ce ne seront que des méthodes prédéfinies. Alors que si vous créez une fenêtre à partir d' une classe dérivée de JFrame, une classe que vous aurez définie vous même, vous pourrez alors créer vos propres méthodes. Ce qui, en programmation, est évidement très intéressant pour résoudre certains problèmes que des méthodes prédéfinies ne peuvent pas faire. Ainsi, si je veux donner des dimensions à ma fenêtre avant même son apparition sur l' écran, je peux le faire. Ici, j'ai mis les instructions adéquates dans le constructeur de ma classe (dérivée de JFrame). Cette classe hérite, par définition de toutes les méthodes de la classe JFrame et aussi, et c' est évident, de toutes les méthodes de toutes les classes ascendantes de JFrame. Maintenant, mettons en oeuvre la programmation évènementielle. Autrement dit, comment traiter un évènement en java. COmmençons par un simple clic dans une fenêtre. |
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.yellow);
12. setSize(500, 300);
13. setLocationRelativeTo(this.getParent());
14. setVisible(true);
15. setDefaultCloseOperation(3);
16. }
17. }
18.
19.
20.
21. class EcouteurDeSouris implements MouseListener
22. {
23. public void mouseClicked(MouseEvent e)
24. {
25. System.out.println("Vous venez de cliquer sur la fenêtre graphique");
26. }
27.
28. public void mousePressed(MouseEvent e){}
29.
30. public void mouseReleased(MouseEvent e){}
31.
32. public void mouseEntered(MouseEvent e){}
33.
34. public void mouseExited(MouseEvent e){}
35. }
36.
37.
38. public class TesterClicFenetre
39. {
40. public static void main(String [] args)
41. {
42. JFrame f = new Fenetre();
43. EcouteurDeSouris eds = new EcouteurDeSouris();
44. f.addMouseListener(eds);
45. }
46. }
|
|
Compilez puis exécutez ce programme. il sera affiché : Au centre de l'écran de votre ordinateur (quel que soit votre PC), apparaitra la fenêtre JFrame. Cliquez sur la fenêtre graphique, il sera alors affiché sur la fenêtre console, cette phrase : vous venez de cliquer sur la fenêtre graphique Cliquez à nouveau sur la fenêtre graphique et la même phrase sera affichée sur la fenêtre console. Autant de fois que vous voulez. Explications : Commençons par expliquer la ligne 3 : le package java.awt.event permet de gérer les évènements. Expliquons maintenant la classe qui permet de créer la fenêtre. Elle est dérivée de la classe JFrame. Et forcément, elle sera toujours dérivée d'une classe prédéfinie par java. Classe Window, classe Frame, etc... Dans le constructeur de cette classe, je mets les caractéristiques de la fenêtre que je vais instancier. setTitle() pour donner un titre à ma fenêtre. Lignes 10 et 11 : pas utile. Je mets un conteneur dans ma fenêtre (ligne 10) que je colore en jaune (ligne 11). Ah tiens, c'est nouveau ça. Avant, je créais un objet couleur en l'instanciant à partir de la classe Color. Ex : Color couleur = new Color(). Cette fois, j'utilise plutôt une contante de la classe Color. Certains couleurs sont justement des constantes. Ex :Color.red (rouge), Color.green (vert), Color.black (noir), Color.cyan (rouge), etc... ATTENTION !!! ... Je n'ai pas besoin de colorer la fenêtre pour expliquer la gestion d'un évènement. C' était juste pour vous montrer une autre façon de colorer une fenêtre. setSize() pour donner une taille à ma fenêtre. La ligne 13 permet de centrer ma fenêtre. La méthode setLocationRelativeTo() permet justement de centrer une fenêtre. Mais attention, centrer par rapport à quoi ? ... C' est justement l'objet par rapport auquel on centre la fenêtre qui est l' argument de cette méthode. Si j'avais déjà créé une première fenêtre, et que j'avais voulu centrer par rapport à celle-ci, c'est donc cette fenêtre qui aurait été l'argument de la méthode. Ici, je cherche à centrer par rapport à l'écran de l'ordinateur. C'est donc l'écran de l'ordinateur qui est l'objet par rapport auquel on doit centrer. On obtient cet objet par la méthode getParent(). La méthode getParent() permet en fait d'obtenir une fenêtre parent de la fenêtre sur laquelle on applique la méthode. Ici, on applique la méthode à this. Vous vous souvenez de this ? C'est l'objet sur lequel on applique une méthode. Et ici, c'est l'objet de la classe Fenetre qu' on vient de créer. Ici, c'est f. Le parent de f, c'est quoi ? ... Forcément c' est l'écran du PC. Parcequ'on n'a pas créé f à partir d'une autre fenêtre. Son seul parent est donc l'écran. Expliquons maintenant la classe déclarée en ligne 21 : EcouteurDeSouris. Quand on veut gérer un évènement en java, on crée une classe qui implémente une interface particulière. Cette interface contient forcément une méthode permettant de gérer l' évènement en question. Ici, nous voulons gérer le clic dans une fenêtre. La méthode correspondante est mousCliked(). Vous ne l'inventez pas. Cette méthode est déclarée dans l'interface MouseListener. Cette interface est prédéfinie par le langage. Vous ne l'inventez pas non plus. Dans cette interface, on trouve 4 autres méthodes : mousePressed() : pour gérer l' évènement appui sur la souris dans la fenêtre. Lorsque vous cliquez, vous effectuez en fait 2 actions. Un appui et un relachement successifs. mouseReleased() : pour gérer le relachement de la souris dans la fenêtre. mouseEntered : pour gérer l'entrée de la souris dans une fenêtre. mouseExited : pour gérer la sortie de la souris d' une fenêtre. Ces 4 méthodes appartiennent à l'interface (prédéfinie) MouseListener. Pour gérer un évènement en java (redisons le), on crée une classe qui implément une interface contenant la méthode permettant de gérer l' évènement. Ma classe EcouteurDeSouris implémente donc l'interface MouseListener. Car c'est cette interface qui contient la méthode permettant de gérer le clic dans une fenêtre. Lorsqu'une classe implémente une interface, elle doit redefinir toutes les méthodes de cette interface. C' est pourquoi nous reprenons les 5 méthodes de l'interface MouseListener dans notre classe. On peut redéfinir une méthode en n'y mettant rien dedans. Cela tombe bien. Nous avons besoin de gérer le clic et rien d'autre. Nous pouvons donc nous permettre de déclarer les autres méthodes sans rien mettre dedans. La seule méthode qui nous intéresse, c' est mouseClicked(). C' est donc à l'intérieur de cette méthode que nous allons mettre les intructions correspondantes à ce qui doit se passer lorsque nous cliquons dans une fenêtre. Et si vous regardez la ligne 25, vous verrez : System.out.println("vous venez de cliquer sur la fenêtre graphique"); Comme vous le savez déjà, la méthode System.out.println() permet d' écrire dans une fenêtre console. C' est pourquoi, en cliquant sur la fenêtre graphique, vous verrez affiché cette phrase sur la fenêtre console. En fait, ce n'est pas suffisant de créer cette classe qui implémente MouseListener en redéfinissant la méthode adéquate pour que l' évènement soit traité. Encore faut-il associer à la fenêtre, un objet instancié à partir de cette classe. C'est justement ce qui est fait en ligne 44. En ligne 43, on crée un objet EcouteurDeSouris (classe qui implémente l'interface MouseListener). Puis en ligne 44, on l' associe à l' objet de type fenetre qu' on vient de créer grâce à la méthode addMouseListener(). Relisez le dernier paragraphe, juste avant l'exemple zéro. Et vous comprendrez mieux. Pour traiter un évènement en java, on associe à l' objet source, un autre objet, instancié à partir d'une classe qui implémente une interface particulière. La particularité de cette interface est qu'elle est prédéfinie. Vous ne l'inventez pas. En plus, cette interface possède un ensemble de méthodes dont l'une d'elle permet justement de traiter l' évènement en question. L' objet source ici, c' est la fenêtre, donc f. L' objet dont la classe implémente cette interface particulière, c' est eds, instancié à partir de la classe EcouteurDeSouris qui implémente MouseListener. Si ce n' est pas encore clair, je vous conseille de recommencer la lecture. Ce n'est pas difficile. Vous verrez. |
| On peut présenter les choses de façon un peu moins détaillée. Au prochain exemple, nous allons reprendre le programme ci-dessus en tapant un peu moins de code. |
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.yellow);
12. setSize(500, 300);
13. setLocationRelativeTo(this.getParent());
14. setVisible(true);
15. setDefaultCloseOperation(3);
16. }
17. }
18.
19.
20.
21. class EcouteurDeSouris extends MouseAdapter
22. {
23. public void mouseClicked(MouseEvent e)
24. {
25. System.out.println("Vous venez de cliquer sur la fenêtre graphique");
26. }
27.
28. }
29.
30.
31. public class TesterClicFenetre2
32. {
33. public static void main(String [] args)
34. {
35. JFrame f = new Fenetre();
36. EcouteurDeSouris eds = new EcouteurDeSouris();
37. f.addMouseListener(eds);
38. }
39. }
|
|
Ce programme fournit le même résultat que le précédent. Inutile donc de vous dire ce qui sera affiché. Mais le code a changé. Il faut l'expliquer.
Maintenant, la classe EcouteurDeSouris n'implémente plus l'interface MouseListener. Elle est dérive plutôt de la classe MouseAdapter. La classe MouseAdapter est une classe prédéfinie. Elle a cette particularité d' implémenter l'interface MouseListener. Lorsqu'une classe A dérive d'une classe B, toutes les interfaces implémentées par B sont automatiquement implémentées par A. Autrement dit, la classe EcouteurDesOuris ci-dessus implémente automatiquement l'interface MouseListener. Cette façon indirecte d'implémenter MouseListener lui permet de s'bastenir de redéfinir toutes les méthodes de MouseListener. C' est pourquoi elle peut se permettre de redéfinir la seule méthode dont nous avons besoin : la méthode mouseClicked(). Maintenant, vous comprenez le nouveau code. |
Exemple 3 :
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.yellow);
12. setSize(500, 300);
13. setLocationRelativeTo(this.getParent());
14. setVisible(true);
15. EcouteurDeSouris eds = new EcouteurDeSouris();
16. addMouseListener(eds);
17. setDefaultCloseOperation(3);
18. }
19. }
20.
21. class EcouteurDeSouris extends MouseAdapter
22. {
23. public void mouseClicked(MouseEvent e)
24. {
25. System.out.println("Vous venez de cliquer sur la fenêtre graphique");
26. }
27.
28. }
29.
30.
31. public class TesterClicFenetre3
32. {
33. public static void main(String [] args)
34. {
35. JFrame f = new Fenetre();
36. }
37. }
|
|
Ce programme fournit le même résultat que le précédent. Inutile donc de vous dire ce qui sera affiché. Mais le code a changé. Il faut l'expliquer.
En ligne 16 : L'objet EcouteurDeSouris a été créé directement dans le constructeur de la classe Fenetre. Rien d'étonnant. Puisque c'est à l'objet f instancié à partir de cette fenêtre qu'on va associer l'objet EcouteurDeSouris. EN ligne 17 : on associe donc l'objet EcouteurDeSouris par la méthode addMouseListener(). Mais cette fois, on n'écrit pas f.addMouseListener(eds); Parce que la méthode appliquée sera appliquée à tout objet Fenetre créé. On peut encore améliorer le code. D'abord, je pense que l'intruction setVisible(true); n'est pas au bon endroit dans le constructeur. Il vaut mieux la mettre comme dernière instruction. Parce que s' il y a un grand nombre d'intructions après setVisible(true); La fenêtre sera vue avant même que la gestion de l' évènement soit prise en compte. Et dans ce cas, les premiers clics risquent de ne rien donner. Et si ce n' était que ça, ce serait pas bien grave. Imaginez quelque chose de plus conséquent. L'utilisateur du logiciel pourrait croire que ça ne marche pas. Alors, dans ces conditions, l'intruction sera mise à la fin. Mais mieux encore, je la mettrais dans la méthode main() après avoir créé l' objet Fenetre. |
Exemple 4 :
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.yellow);
12. setSize(500, 300);
13. setLocationRelativeTo(this.getParent());
14.
15. EcouteurDeSouris eds = new EcouteurDeSouris();
16. addMouseListener(eds);
17. setDefaultCloseOperation(3);
18. }
19. }
20.
21. class EcouteurDeSouris extends MouseAdapter
22. {
23. public void mouseClicked(MouseEvent e)
24. {
25. System.out.println("Vous venez de cliquer sur la fenêtre graphique");
26. }
27.
28. }
29.
30.
31. public class TesterClicFenetre4
32. {
33. public static void main(String [] args)
34. {
35. JFrame f = new Fenetre();
36. f.setVisible(true);
37. }
38. }
|
|
Jusqu' ici, nous sommes passés à côté d'un objet. Celui qui est l'argument des méthodes de l'interface MouseListener. C'est l'objet e de la
classe MouseEvent. Parlons-en ! La classe MouseEvent, comme toute classe permet de créer un objet. Cet objet est un évènement. Cet objet est en fait créé automatiquement lorsqu'on utilise l'une des méthodes de l'interface MouseListener. L'objet ainsi créé est transmis à la méthode mouseClicked(). Parce que seule la méthode mouseClicked() est utilisée ici. Mais cet objet sera transmis à toute méthode de l'interfce MouseListener si elle est utilisée. Vous n'avez donc pas besoin de créer un Objet de type MouseEvent pour le mettre dans les parenthèses d'une des 5 méthodes de MouseListener. Cet Objet possède des informations intéressantes. En l'occurence, on peut lui appliquer la méthode getClickCount() qui renvoie le nombre de fois où l'on a cliqué dans la fenêtre. Deux autres méthodes sont intéressantes : getX() et getY() qui renvoient respectivement l'abscisse et l'ordonnée du point correspondant à l'endroit cliqué dans la fenêtre. Et d'autres méthodes ou champs que nous verrons dans certains exemples. |
Exemple 5 :
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.green);
12. setSize(500, 300);
13. setLocationRelativeTo(this.getParent());
14. setVisible(true);
15. EcouteurDeSouris eds = new EcouteurDeSouris();
16. addMouseListener(eds);
17. setDefaultCloseOperation(3);
18. }
19. }
20.
21. class EcouteurDeSouris extends MouseAdapter
22. {
23. public void mouseClicked(MouseEvent e)
24. {
25. System.out.println("Vous avez cliqué au point : " + e.getX() + " et " + e.getY() );
26. }
27.
28. }
29.
30.
31. public class TesterClicFenetre5
32. {
33. public static void main(String [] args)
34. {
35. JFrame f = new Fenetre();
36. }
37. }
|
|
Cette fois, si vous cliquez, le message suivant sera affiché sur la fenêtre console : Vous avez cliqué au point : x et y. Bien entendu, x et y sont les coordonnées du point où le clic a eu lieu dans la fenêtre graphique. La méthode getX() renvoie l'abscisse du point (sens de la largeur de la fenêtre) et la méthode getY() renvoie l'ordonnée (le sens de la hauteur de la fenêtre). |
Exemple 6 :
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.cyan);
12. setSize(500, 300);
13. setLocationRelativeTo(this.getParent());
14. setVisible(true);
15. EcouteurDeSouris eds = new EcouteurDeSouris();
16. addMouseListener(eds);
17. setDefaultCloseOperation(3);
18. }
19. }
20.
21. class EcouteurDeSouris extends MouseAdapter
22. {
23.
24. public void mouseClicked(MouseEvent e)
25. {
26.
27. System.out.println("Nombre de clics = " + e.getClickCount() );
28. }
29. }
30.
31. public class TesterClicFenetre6
32. {
33. public static void main(String [] args)
34. {
35. JFrame f = new Fenetre();
36. }
37. }
|
|
Cette fois, si vous cliquez, le message suivant sera affiché sur la fenêtre console : Nombre de clics = n (n étant le nombre de clics effectués dans la fenêtre, sur le même point). Si vous faîtes un clic, il sera affiché : Nombre de clics = 1 Si vous faites 2 clics au même endroit et dans un intervalle très court pour être considéré comme double clic, alors il sera affiché : Nombre de clics = 2 Mais si l'intervalle entre 2 clics n'est pas suffisament court, alors il sera affiché : Nombre de clics = 1 Nombre de clics = 1 |
| Il peut arriver que la fenêtre elle-même soit EcouteurDeSouris. Au lieu de créer une classe à part, on peut faire en sorte que la classe Fenetre implémente l'interface MouseListener. Dans ce cas, impossible d'utiliser MouseAdapter. Et pour cause, en java, l'héritage multiple n'existe pas. |
Exemple 7 :
1. import javax.swing.*;
2. import java.awt.*;
3. import java.awt.event.*;
4.
5. class Fenetre extends JFrame implements MouseListener
6. {
7. public Fenetre()
8. {
9. setTitle("Une fenêtre dynamique");
10. Container c = getContentPane();
11. c.setBackground(Color.cyan);
12. setSize(500, 300);
13. setLocationRelativeTo(this.getParent());
14.
15. addMouseListener(this);
17. setDefaultCloseOperation(3);
18. }
19.
20. public void mouseClicked(MouseEvent e)
21. {
22. System.out.println("Vous venez de cliquer dans la fenêtre graphique");
23. }
24. public void mousePressed(MouseEvent) {}
25. public void mouseReleased(MouseEvent) {}
25. public void mouseEntered(MouseEvent) {}
26. public void mouseExited(MouseEvent) {}
27. }
28.
29.
30. public class TesterClicFenetre7
31. {
32. public static void main(String [] args)
33. {
34. JFrame f = new Fenetre();
35. f.setVisible(true);
36. }
37. }
|
|
Cette fois, je n'ai pas créé de classe EcouteurDeSouris. C' est la fenêtre elle-même qui écoute la souris. De ce fait, la classe Fenetre implemente
l'interface MouseListener. Ne soyez pas étonné de la ligne 5. Une classe peut dériver d'une autre classe et en même temps implémenter une
interface. Ici, on est bien obligé de redéfinir toutes les méthodes de l'interface MouseListener. Bien entendu, puisqu'on n'a pas besoin des
autres méthodes, on les redéfini à vide. Pas d'instruction. Personnellement, je vous conseillerais d'opter pour cette façon de faire seulement lorsque vous avez besoin de toutes les méthodes (ou presque) de l' interface MouseListener. Par ailleurs, si vous avez un gros problème à résoudre avec plusieurs évènements à gérer, les choses seront plsu claires (en tout cas, moins touffues) si vous créez une classe écouteuse. J'irais même plus loin. Moi, j'ai pris l'habitude de mettre cette classe écouteuse dans un fichier à part. Vous vous rendrez compte tôt ou tard, à quel point c' est plus aisé dans un programme lourd. Un peu comme une page css avec plusieurs pages HTMl, une page JavaScript ou une page PHP avec plusieurs pages HTML. Autre chose : puisque l' objet Fenetre est aussi celui qui écoute la souris, la méthode addMouseListener() aura pour argument un objet Fenetre. Et il n'est pas utilie d' instancier un nouvel objet Fenetre (mais ce n'est pas interdit) pour l'utiliser dans les parenthèses de la méthode. On utilise l'objet Fenetre sur lequel on clique. Pour cette raison, on écrit dans le constructeur : addMouseListener(this); Ou alors, dans la méthode main, on écrit : f.addMouseListener(this); ou f.addMouseListener(f); Je rappelle que this fait référence à l'objet courant. C' est à dire, l'objet sur lequel on applique la méthode. |
|
Exercice : reprenez l'exemple 4 : 1. Compilez puis exécutez. Pour cliquer, commencez d'abord par un appui. Attendez un instant sans bouger la souris. Il ne sera rien affiché. Mais dès que vous relachez, la réaction attendue se produit. Sur la fenêtre console, il sera affiché Vous venez de cliquer dans la fenêtre graphique. Un clic = un appui, suivi d'un relachement du bouton gauche de la souris. Mais à condition que la souris n'ait pas bougé. 2. Faîtes la même chose que ci-dessus. Mais entre l'appui et le relachement, faites bouger la souris. Il ne se passera rien. Car, ce n'est pas un clic. La plupart des informaticiens appellent ça le glisser-déposer. Cet évènement est traité par la méthode mouseDragged() de l'interface MouseMotionListener. On verra cette interface plus tard. 3. Regardez la ligne 23, déclaration de la méthode mouseClicked(). Changez le nom de la méthode. Mettez mousePressed(). Recompilez puis exécutez. Pour cliquer, commencez par l'appuis. Aussitôt, la réaction se produit. Sur la fenêtre console, il sera affiché Vous venez de cliquer dans la fenêtre graphique. Pourquoi ? ... parce que cette fois, vous traitez l'évènement mousePressed. C' est à dire, l'appui du bouton de la souris. Dès que vous relâchez le bouton, il ne se passe rien. Puisque vous ne gérez plus le clic, mais l'appui. 4. Regardez toujours la ligne 23, déclaration de la méthode mousePressed(). Changez le nom de la méthode. Mettez mouseReleased(). Recompilez puis exécutez. Pour cliquer, commencez par l'appui. Il ne se passe rien. Mais dès que vous relâchez, aussitôt, la réaction se produit. Sur la fenêtre console, il sera affiché Vous venez de cliquer dans la fenêtre graphique. Pourquoi ? ... parce que cette fois, vous traitez l'évènement mouseReleased. C' est à dire, le relâchement du bouton de la souris. 5. Regardez toujours la ligne 23, déclaration de la méthode mouseReleased(). Changez le nom de la méthode. Mettez mouseEntered(). Recompilez puis exécutez. Cette fois, arrangez vous pour que la souris soit hors de la zone où apparaîtra la fenêtre. Puis faîtes entrez la souris dans la fenêtre graphique. Aussitôt, sur la fenêtre console, il sera affiché Vous venez de cliquer dans la fenêtre graphique. Pourquoi ? ... parce que cette fois, vous traitez l'évènement mouseEnterded. C' est à dire, l'entrée de la souris dans la fenêtre graphique. 6. Regardez toujours la ligne 23, déclaration de la méthode mouseEntereded(). Changez le nom de la méthode. Mettez mouseExited(). Recompilez puis exécutez. Cette fois, arrangez vous pour que la souris soit dans de la zone où apparaîtra la fenêtre. Puis faîtes sortir la souris de la fenêtre graphique. Aussitôt, sur la fenêtre console, il sera affiché Vous venez de cliquer dans la fenêtre graphique. Pourquoi ? ... parce que cette fois, vous traitez l'évènement mouseExited. C' est à dire, la sortie de la souris dans la fenêtre graphique. Evidement, il serait plus intéressant de changer à chaque fois la phrase qui sera affichée. mousePressed() --> Vous venez d'appuyer sur la souris mouseReleased() --> Vous venez de relâcher la souris. mouseEntered() --> La souris vient d'entrer dans la fenêtre mouseExited() ---> La souris vient de sortir de la fenêtre. Le premier boulot d' un informaticien, c'est d'être logique, même en ce qui concerne les messages affichés. Surtout en ce qui concerne les messages affichés. |
|
Avant de quiter ce chapitre, résumons le traitement d'un évènement en expliquant les choses de façon générale. La programmation graphique est encore appelée programmation évènementielle. C' est d'ailleurs l'expression qui lui convient mieux. Un évènement, c' est l'action d'un utilisateur sur un composant graphique. Il s'en suit alors un autre évènement qui est la réaction engendrée par le programme. Pour traiter un évènement en Java : Il faut connaitre l' objet source. J'entends par là, l'objet ayant donné naissance à l' évènement. Attention : l'objet ayant donné naissance au clic n'est pas la souris, même si cela parait plus vraisemblable. Java considère que c' est plutôt l'objet sur lequel le clic a été effectué. Clic dans une fenêtre, c' est la fenêtre qui est l'objet source. Clic sur un bouton, c'est le bouton qui est l'objet source. Etc,... Il faut aussi connaître la méthode (toujours predéfinie) qui permet de traiter l'évènement. En fait, il faut surtout connaitre l'interface (toujours prédéfinie) dans laquelle cette méthode est déclarée. On crée alors une classe qui implémente cette interface. Qui dit implémentation, dit redéfinition de toutes les méthodes de l'interface. Eventuellement, redéfinition à vide des méthodes qui n'intéressent pas le programmeur. Dans la définition de la méthode qui permet de traiter l'évènement, on met les intructions correspondantes à la réaction. C' est à dire, ce qui doit se passer lorsque l'utilisation produit l' évènement à traiter. Enfin, on associe à l'objet source, l'objet écouteur en écrivant : nom de l' objet, suivi d' un point, suivi de la méthode associative dont les parenthèses contiennent le nom de l' objet écouteur. L'objet écouteur est instancié à partie de la classe qui implément l'interface contenant la méthode permettant de traiter l'évènement. La méthode associative est la méthode qui permet d'asocier les 2 objets. Elle est de la forme addXXXListener(). XXXListener étant toujours le nom de l' interface. Ex : MouseListener, ActionListener, ItemListener, etc... Comme d'habitude, si vous n'avez pas compris, relisez, je suis persuadé que vous comprendrez. |
| ← (précédent) D.1 Les bases de la programmation graphique : fenêtre statique |
| D.3 Evènements boutons simples → |
| Accueil ↔ S O M M A I R E |
D.2 Les bases de la programmation graphique : |