| ← (précédent) D.0 Les interfaces graphiques (généralités) |
| D.2 Les bases de la programmation graphique : fenêtre Dynamique → |
| Accueil ↔ S O M M A I R E |
D.1 Les bases de la programmation graphique : |
|
Pour une meilleure explication des exemples suivants, sachez que : La classe JFrame permet de créer une fenêtre. Mais elle n'est pas la seule. Mais pour un débutant, il vaut mieux commencer par JFrame. Cette classe possède plusieurs classes supérieures dont : La classe Window (qui permet de créer une fenêtre elle aussi). La classe Container La classe Component et bien entendu, la classe Object qui est la mère de toutes les classes. Dans cette fenêtre, on pourra mettre divers types de composants graphiques tels que les boutons, les cases à cocher, les boutons radio, etc... Mais pour ce chapitre, tout sera statique. Autrement dit, il n y aura aucune réaction sur ces composants. Par exemple, en cliquant sur un bouton, il ne se passera rien. Au chapitre suivant, nous apprendrons comment mettre en oeuvre la programmation évènementielle. C' est à dire, la réaction des composants graphiques suite à l'action de l'utilisateur. |
Exemple 1 :
1. import javax.swing.*;
2.
3. public class Fenetre1
4. {
5. public static void main(String [] args)
6. {
7. JFrame f = new JFrame();
8. f.setSize(350, 175);
9. f.setTitle("fenetre java");
10. f.setVisible(true);
11. }
12. }
|
|
Compilez puis exécutez ce programme, il sera affiché : Une fenêtre de dimensions : largeur = 350 pixels et hauteur = 175 pixels. Sur la partie supérieure de cette fenêtre, apparaît un texte : fenetre java Cette fenêtre apparaît tel que son coin supérieur gauche coincide avec le coin supérieur gauche de l' écran de votre ordinateur. C'est une fenêtre qui ressemble aux fenêtres classiques de tout logiciel du commerce. Sur le coin supérieur droit, vous avez trois boutons classiques : l' une permettant de réduire la fenêtre. Le suivant permettant d'agrandir. Et le dernier permettant de fermer la fenêtre. Explications : En ligne 1, on fait appel au package javax.swing qui continet un grand nombre de classes dont la classe JFrame qui permet de créer une fenêtre. D' autres classes prédéfinies permettent aussi de créer des fenêtres. En ligne 7, on crée donc un objet fenêtre avec la classe JFrame. En ligne 8 : on applique à cet objet la méthode setSize(). Cette méthode de la classe JFrame donne des dimensions à la fenêtre f. Elle requiert 2 arguments de type int. Le premier est la largeur de la fenêtre. Le deuxième est la hauteur de la fenêtre. Ces nombres ont pour unité, le pixel. En ligne 9 : on applique à l' objet f, la méthode setTitle() qui requiert un argument de type String dont la valeur est le titre que vous voulez donner à votre fenêtre. En ligne 10 : on applique à l' objet f, la méthode setVisible() qui requiert un argument de type boolean. Lorsque la valeur est true, cela veut dire que la fenêtre doit être visible. Si la valeur est false, cela veut dire que la fenêtre doit être invisible. ATTENTION : fenêtre invisible ne veut pas dire que la fenêtre n' existe pas. Cela veut dire que la fenêtre est invisible. Cet objet fenêtre existe bel et bien en mémoire. Pour qu'elle n'existe plus, il faut la détruire explicitement. On verra cela plus tard. Attention, le fait de fermer la fenêtre ne signifie pas que le programme s' est arrêté. La preuve, vous ne pouvez pas compiler un programme à nouveau. Pour y arriver, il faudra d'abord fermer la fenêtre console. Cette fenêtre sur laquelle vous tapez javac nomDuProgmme.jeva Pour arrêter le programme, il faudra mettre un bout de code spécifique qui fera que la fermeture de la fenêtre graphique entrainera aussi la fin du programme. Mais avant de voir cela, voyons d'abord quelque chose de plus important. La fonction System.out.print() permet-elle d' écrire sur la fenêtre graphique ? |
Exemple 2 :
1. import javax.swing.*;
2.
3. public class Fenetre2
4. {
5. public static void main(String [] args)
6. {
7. JFrame f = new JFrame();
8. f.setSize(350, 175);
9. f.setTitle("fenetre java");
10. f.setVisible(true);
11. System.out.println("s' afficher où ?");
12. }
13. }
|
|
Compilez puis exécutez ce programme, il sera affiché : la même chose que ci-dessus En plus de ça, sur la fenêtre console affiche ceci : s' afficher où ?. Sur la fenêtre graphique, rien du tout. En effet, System.print() ou sa variante System.println() ne permettent pas d' afficher sur la fenêtre graphique. Mais seulement sur la console. Pour afficher sur la fenêtre graphique, on utilise une autre méthode. On le verra dans l'un des chapitres suivants. |
Exemple 3 :
1. import javax.swing.*;
2.
3. public class Fenetre3
4. {
5. public static void main(String [] args)
6. {
7. JFrame f = new JFrame();
8. f.setSize(350, 175);
9. f.setTitle("fenetre java");
10. f.setVisible(true);
11. f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12. }
13. }
|
|
Compilez puis exécutez ce programme, il sera affiché : la même chose que l'exemple 1 Fermez la fenêtre en cliquant sur le bouton situé au coin supérieur droit. Comme toute fenêtre de n'importe quel logiciel du commerce. Et la fenêtre se ferme. En même temps, le programme s'arrête. Vous ne serez pas obligé de fermer le fenêtre console pour recompiler à nouveau. Explications : La méthode setDefaultCloseOperation() de la classe JFrame permet de définir l' action à réaliser lorsqu' on ferme une fenêtre JFrame en cliquant sur son coin supérieur droit (bouton contenant le signe x). Pour ce faire, il requiert 1 argument (parmi 4) qui sont des nombres appartenant à des variables déclarées avec le mot clé final. Donc, des constantes. Ces variables sont en fait héritées de la classe Window, l' une des classes mère de la classe JFrame. Ce sont : public static final int DO_NOTHING_ON_CLOSE : Ne rien faire après fermeture. valeur = 0 public static final int HIDE_ON_CLOSE : Cacher le fenêtre après fermeture. Valeur = 1 public static final int DISPOSE_ON_CLOSE : pour détruire l' objet JFrame après fermeture. Valeur = 2 public static final int EXIT_ON_CLOSE : Mettre fin au programme, Sortir du programme après fermeture. Valeur = 3 Puisque ces variables (constantes) appartiennent à la classe JFrame, pour les utiliser dans une autre classe, il faut invoquer la classe JFrame. On peut aussi remplacer le nom de la variable par sa valeur. Autrement dit, si vous remplacez le nom de la variable JFrame.EXIT_ON_CLOSE par le nombre 3, on a le même résultat. |
Exemple 4 :
1. import javax.swing.*;
2.
3. public class Fenetre4
4. {
5. public static void main(String [] args)
6. {
7. JFrame f = new JFrame();
8. f.setBounds(50, 75, 350, 175);
9. f.setTitle("fenetre java");
10. f.setVisible(true);
11. f.setDefaultCloseOperation(3);
12. }
13. }
|
|
Compilez puis exécutez ce programme, il sera affiché : la même chose que l'exemple 1 Avec une légère différence tout de même. Le coin supérieur gauche de la fenêtre ne correspond plus au coin supérieur gauche de votre écran. Il est décalé de 50 pixels vers la droite (largeur) et de 75 pixels vers le bas (la hauteur). Pourquoi ? ... Parce que la méthode setBounds() permet non seulement de donner des dimensions à la fenêtre (3ème et 4ème argument : 350 de largeur et de 175 de hauteur), mais aussi de donner les coordonnées du coin supérieur gauche de la fenêtere (1er et deuxième argument : 50 de largeur et 75 de hauteur). |
Exemple 5 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre5
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(350, 175);
10. Container c = f.getContentPane();
11. Color couleur = new Color(208, 255, 208);
12. c.setBackground(couleur);
13. f.setVisible(true);
14. f.setDefaultCloseOperation(3);
15. }
16. }
|
|
Compilez puis exécutez ce programme, il sera affiché : Une fenêtre de dimensions, 370 sur 175 pixels. Elle apparaitra avec un fond vert. Explications : Une fenêtre de type JFrame (d' autres classes permettent de créer une fenêtre. Exemple : Frame, Window, etc...) a une structure quelque peu complexe. Sans entrer dans les détails, sachez que pour y mettre quoi que ce soit, y compris une coloration, on est obligé de créer un objet conteneur sur cette fenêtre. C' est alors sur cet objet conteneur qu' on pourra mettre des boutons, des cases à cocher, des zones de texte, etc... Impossible de mettre quoi que ce soit directement sur la fenêtre de type JFrame. En fait, c' est possible d' y mettre des choses. Mais ces choses disparaîtront rapidement. Ou alors, seraient modifiées selon l' environnement de programmation. Enfin bref, toujours sans entrer dans les détails, vous devez créer un objet de type Container. La classe Container (conteneur en français) appartient au package java.awt. D' où l' intruction import java.awt.*; Cet objet s' obtient, non pas en faisant Container c = new Container(); Mais en appelant une méthode de la classe JFrame. C' est la méthode getContentPane(). La ligne 10 permet alors d'obtenir cet objet conteneur. On obtient la couleur grâce à la classe Color du package java.awt. Le contructeur utilisé requiert 3 nombres entiers correspondants respectivement aux couleurs vert, rouge et bleu. Chaque nombre varie entre 0 et 255. La méthode setBackground() de la classe JFrame permet de donner de la couleur de fond à un objet de type JFrame. Elle requiert pour cela un argument de type Color. D' où couleur, l' objet instancié en ligne 11. En réalité, la méthode setBackground() appartient à la classe Component. JFrame hérite donc de cette méthode. Remarque : Dans les autres exemples, j' ai créé l'objet JFrame avec un constructeur sans arguments. JFrame f = new JFrame(); Dans l' exemple ci-dessus, le constructeur utilisé requiert un argument de type String. JFrame f = new JFrame(); La valeur de cette variable est le titre de la fenêtrede type JFrame. On n'a donc plus besoin d'appeler la méthode setTitle() pour donner un titre à la fenêtre. |
Exemple 6 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre6
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(350, 175);
10. Container c = f.getContentPane();
11. JButton bouton = new JButton();
12. c.add(bouton);
13. f.setVisible(true);
14. f.setDefaultCloseOperation(3);
15. }
16. }
|
|
ligne 8 : création d' une fenêtre intitulée fenêtre java. ligne 9 : taille de la fenêtre. ligne 10 : création d'un conteneur. ligne 11 : création
d'un bouton grâce à la classe JButton. Ce bouton, je l'ai appelé bouton. ligne 12 : j'ajoute le bouton dans le conteneur grâce à la méthode add().
La méthode add() appartient à la classe Container. Si vous compilez puis exécutez ce programme, la fenêtre s'affiche. Mais vous ne verrez pas le bouton. Pourquoi ? ... Parce que en fait, le bouton occupe toute la surface de la fenêtre. Il se confond alors avec la surface de la fenêtre. Pourquoi ? ... Parce que la disposition des composants graphiques dans une fenêtre JFrame est gérée par un gestionnaire de mise en forme. Il existe plusieurs gestionnaires de mise en forme. Celui qui est utilisé par défaut (donc ici) s' appelle BorderLayout. Comme il fallait s' y attendre, c' est une classe. La classe BorderLayout. En l' absence d' informations spécifiques, ce gestionnaire permet au composant d'occuper toute la bordure de la fenêtre. Donc, toute la surface de la fenêtre. Il existe un autre gestionnaire de mise en forme appelée : FlowLayout. Comme on peut s'y attendre, c' est une classe. La classe FlowLayout. Ce gestionnaire permet de disposer les composants graphique en "flot". C' est à dire comme du texte. D' abord toute une ligne. Ensuite, ligne suivante, a ainsi de suite. Voyons comment l' utiliser. |
Exemple 7 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre7
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(350, 175);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. JButton bouton = new JButton("le bouton");
14. c.add(bouton);
15. f.setVisible(true);
16. f.setDefaultCloseOperation(3);
17. }
18. }
|
|
Cette fois, après compilation, puis exécution, une fenêtre s' affichera avec un bouton visible contenant un nom : le bouton Explications : ligne 8 : création d' une fenêtre avec un titre ("fenêtre java"). ligne 9 : taille de la fenêtre. Ligne 10 : création d' un conteneur dans la fenêtre f. ligne 11 : création d' un gestionnaire de mise en forme permettant de mettre des composants graphiques dans une fenêtre de façon séquentielle. C'est à dire, sous forme de flot. ligne 12 : puisque c' est en fait le conteneur qui doit recevoir les composants graphiques, il est naturel que ce soit sur lui qu' on applique le gestionnaire de mise en forme. C' est pourquoi on applique à c (l objet conteneur) la méthode setLayout() de la classe Container. Cette méthode requiert un argument de type Gestionnaire de mise en forme. Ici, c' est un objet de la classe FlowLayout. Ligne 13 : je crée un bouton que j'appelle bouton. Cette fois, j'utilise un constructeur qui requiert un argument de type String. Sa valeur est le nom que je donne au bouton. Et ce nom est : le bouton. C' est pourquoi ce nom apparaît sur le bouton à l'affichage. ligne 14 : j' ajoute le bouton au conteneur. ligne 15 : visibilité de la fenêtre. Et ligne 16 : arrêt du programme lorsque l' on ferme la fenêtre. Remarquez : un bouton peut être invisible. On peut donc appliquer à un objet bouton, la méthode setVisible. Mais sachez que contrairement à la fenêtre, le bouton est visible par défaut. Pour le rendre invisible, il suffira de faire : bouton.setVisible(false); N'oubliez pas que rendre invisible un composant ne signifie en aucn cas, le détruire. Il existe toujours en mémoire. Attention. Erreur possible pour un débutant. Le gestionnaire de mise en forme n'est pas ajouté au conteneur grâce à la méthode add(). Seuls les composants graphiques sont ajoutés grâce à add(). Le gestion de mise en forme est toujours ajouté au conteneur par la méthode setLayout(). Et ce, quelque soit le gestionnaire. BorderLayout - FlowLayout - CardLayout - GridLayout - BoxLayout - GridBagLayout Nous verrons tous ces gestionnaires de façon progressive. Pour l'intant, nous nous contenterons de FlowLayout. |
Exemple 8 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre8
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. JButton bouton1 = new JButton("BOUTON 1");
14. JButton bouton2 = new JButton("BOUTON 2");
15. c.add(bouton1);
16. c.add(bouton2);
17. f.setVisible(true);
18. f.setDefaultCloseOperation(3);
19. }
20. }
|
|
Cette fois, après compilation, puis exécution, une fenêtre s' affichera avec un bouton visible contenant 2 boutons appelés : BOUTON1 et BOUTON2 Explications : Comme dans l'exemple précédent. Sauf qu'ici, nous avons créé 2 boutons appelés : boutons1 et bouton2. Sur ces boutons, on a inscrit un nom. BOUTON1 pour bouton1 et BOUTON2 pour bouton2. En ligne 15 : on ajoute le bouton bouton1 au conteneur. Et en ligne 16, on fait la même chose pour le bouton bouton2. Remarquez la disposition des boutons sous forme séquentielle. L' un après l' autre. |
Exemple 9 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre9
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. JCheckBox case1 = new JCheckBox("CASE 1");
14. JCheckBox case2 = new JCheckBox("CASE 2");
15. c.add(case1);
16. c.add(case2);
17. f.setVisible(true);
18. f.setDefaultCloseOperation(3);
19. }
20. }
|
|
Cette fois, après compilation, puis exécution, une fenêtre s' affichera avec 2 cases à cocher appelés : case1 et case2. A côté de ces cases, on peut respectivement lire : CASE 1 et CASE 2 Explications : En ligne 13 : je crée une case à cocher à partir de la classe JCheckBox. J' appelle cette case : CASE 1. Puis, grâce au constructeur adéquat, je place le nom CASE 1 à côté de cette case à cocher. En ligne 14 : je crée une autre case à cocher. Ligne 15 : je place la première case dans le conteneur. Ligne 15 : je place la deuxième case dans le conteneur. Je peux cliquer sur chaque case de la fenêtre. En le faisant, la case sera effectivement cochée. Ainsi : CASE 1 La classe JcheckBox appartient au package javax.swing. |
Exemple 10 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre10
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. JRadioButton radio1 = new JRadioButton("RADIO 1");
14. JRadioButton radio2 = new JRadioButton("RADIO 2");
15. c.add(radio1);
16. c.add(radio2);
17. f.setVisible(true);
18. f.setDefaultCloseOperation(3);
19. }
20. }
|
|
Cette fois, après compilation, puis exécution, une fenêtre s' affichera avec 2 bouton radio appelés : radio1 et radio2. A côté de ces cases, on peut respectivement lire : RADIO 1 et RADIO 2 Explications : En ligne 13 : je crée un bouton radio à partir de la classe JRadioButton. J' appelle ce bouton : radio1. Puis, grâce au constructeur adéquat,je place le nom RADIO 1 à côté de ce bouton radio. En ligne 14 : je crée un autre bouton radio. Ligne 15 : je place le premier bouton radio dans le conteneur. Ligne 15 : je place le deuxième bouton radio dans le conteneur. Je peux cliquer sur chacun des bouton radio. On verra ceci : RADIO 1 RADIO 2 Et ça, ce n'est pas normal. En effet, les boutons radio ont pour vocation d' être sélectioné un seul à la fois. Pour obtenir l'effet de désactivation d' un bouton radio après activation d'un autre, il faut créer un groupe de boutons. Puis associer chaque bouton à ce groupe. Et dans ce groupe, un bouton pourra être désactivé lorsqu' un autre est activé. La classe JRadioButton appartient au package javax.swing. |
Exemple 11 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre11
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. JRadioButton radio1 = new JRadioButton("RADIO 1");
14. JRadioButton radio2 = new JRadioButton("RADIO 2");
15. ButtonGroup groupe = new ButtonGroup();
16. groupe.add(radio1);
17. groupe.add(radio2);
18. c.add(radio1);
19. c.add(radio2);
20. f.setVisible(true);
21. f.setDefaultCloseOperation(3);
22. }
23. }
|
|
Cette fois, après compilation, puis exécution, On ne peut plus sélectionner qu' un seul bouton radio. En sélectionnant l'autre, le précédent se désactive Ainsi : RADIO 1 RADIO 2 Explications : Ici, on a créé un objet de type ButtonGroup en ligne 15. On a ajouté à ce groupe, les 2 boutons radio en lignes 16 et 17. Puis en lignes 18 et 19, on a ajouté ces boutons au conteneur. ATTENTION !!! on n'ajoute pas l' objet ButtonGroup au conteneur. L'objet ButtonGroup (ici, groupe) n'a qu'une seule utilité, permettre la sélection unique d'un bouton radio. Attention : Seuls les boutons radio appartenant au même groupe peuvent se désactiver l'un l'autre. Si on peut sélectionner simultanément 2 boutons radio, ça ne veut dire que 2 choses. Soit ces boutons n'appartiennent pas au même groupe. Soit, pire encore, ces boutons ne sont pas ajouté à un objet de type ButtonGroup. Vous pouvez donc créer 2 (ou plus encore) groupes de boutons. Exemple :
ButtonGroup groupe1 = new ButtonGroup();
ButtonGroup groupe2 = new ButtonGroup();
JRadioButton radio1.1 = new JRadioButton("RADIO 1.1");
JRadioButton radio1.2 = new JRadioButton("RADIO 1.2");
JRadioButton radio2.1 = new JRadioButton("RADIO 2.1");
JRadioButton radio2.2 = new JRadioButton("RADIO 2.2");
groupe1.add(radio1.1); groupe1.add(radio1.2);
groupe2.add(radio2.1) groupe2.add(radio2.2)
radio1.1 et radio1.2 peuvent se désactiver l'un l'autre. De même, radio2.1 et radio2.2 peuvent se désactiver l'un l'autre.Par contre un bouton du groupe 1 ne désactivera jamais un bouton du groupe 2. Et réciproquement. La classe ButtonGroup appartient au package javax.swing |
Exemple 12 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre12
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. JLabel etiquette = new JLabel("marque du produit");
14. c.add(etiquette);
15. f.setVisible(true);
16. f.setDefaultCloseOperation(3);
16. }
17. }
|
|
Une étiquette sert à afficher une information sur une seule ligne. Cette information est non modifiable par l'utilisateur. Mais elle peut être
modifiée par le programme. Ici, l'étiquette s'appelle etiquette et est un objet de type JLabel (ligne 13). On ajoute cet objet au conteneur (ligne 14). L'information sur l'étiquette est : marque du produit Une étiquette sert très souvent à identifier un composant graphique qui ne peut pas l'être. Les boutons, les cases à cocher, les boutons radio peuvent être identifiés au cours de leur création. Mais une zone de texte par exemple ne peut pas l'être. Voyons justement cela dans l'exemple ci-dessous. |
Exemple 13 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre13
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. JLabel info = new JLabel("Votre nom : ");
14. JTextField zoneTexte = new JTextField(20);
15. c.add(info);
16. c.add(zoneTexte);
17. f.setVisible(true);
18. f.setDefaultCloseOperation(3);
19. }
20. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Une fenêtre dans laquelle on voit une étiquette contenant l'expression : Votre nom. Suivie d'une zone de texte sur laquelle vous pouvez saisir une chaine de caractères. Votre nom : Explications : Ce qu' il y a de nouveau ici,c'est l'objet zoneTexte de type JTextField. On la crée en instanciant un objet à partir de la classe JTextField du package javax.swing. Le contructeur utilisé ici requiert un argument de type int dont la valeur est la taille du champ de texte. C' est le nombre de caractères visibles. On peut modifier ce champ (cette zone) de texte en y ajoutant ou en y enlevant un certains caractères. Nous avons 2 composants graphiques ici. Une étiquette et une zone de texte. Grâce au gestionnaire de mise en forme FlowLayout, les deux composants se placent l' un après l'autre. |
Exemple 14 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre14
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. String [] couleurs = {"rouge", "vert", "bleu", "jaune", "orange", "noir", "blanc"};
14. JList liste = new JList(couleurs);
15.
16. c.add(liste);
17. f.setVisible(true);
18. f.setDefaultCloseOperation(3);
19. }
20. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Une fenêtre dans laquelle on voit une étiquette contenant une liste verticale de mots. Explications : En ligne 13 : on crée un objet de type tableau de chaines de caractères. Puis en ligne 14, on crée un objet à partir de la classe JList. Le constructeur de cet objet requiert un argument de type tableau de String qui représente une liste de mots que contiendra la liste. C' est ainsi qu' on peut voir cette liste de mots affiché dans la fenêtre. Remarque : Cette façon de présenter n'est pas toujours très élégante. Imaginez une liste de 30 mots. Il serait plus élégant d'afficher une liste dans laquelle on ne voit que 3 mots de la liste par exemple. Comment faire ? ... exemple suivant. |
Exemple 15 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre15
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. String [] couleurs = {"rouge", "vert", "bleu", "jaune", "orange", "noir", "blanc"};
14. JList liste = new JList(couleurs);
15. JScrollPane panneauDefil = new JScrollPane(liste);
16. liste.setVisibleRowCount(3);
17. c.add(panneauDefil);
18. f.setVisible(true);
19. f.setDefaultCloseOperation(3);
20. }
21. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Une fenêtre dans laquelle on voit une liste verticale de mots. Ce sont évidement les mots du tableau de String couleurs. On ne voit que 3 de ces mots. dans un panneau de défilement. En ligne 15 : on crée le panneau de défilement à l'aide de la classe JScrollPane. Son contructeur requiert un argument de type JList. Ici, c' est justement la liste des couleurs liste qui est l'argument. En ligne 16 : on applique à la liste, la méthode setVisibleRowCount(). Cette méthode permet de cacher un certain nombre d'éléments de la liste en y laissant voir qu' un nombre limité d'éléments de la liste. Ce nombre est justement l'argument de la méthode. Ici, c' est le nombre 3. REMARQUE ! ! ! EN fait, même si on n'utilise pas la méthode setVisibleRowCount(), dès que le nombre de mots de la liste dépasse 8, les autres mots (au delà de 8) sont automatiquement cachés. Attention ! On n'ajoute jamais au conteneur, une liste qui se trouve déjà dans un panneau de défilement. C'est plutôt ce panneau de défilement qu'on ajoute au conteneur. Voir ligne 17 |
Exemple 16 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre16
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. String [] couleurs = {"rouge", "vert", "bleu", "jaune", "orange", "noir", "blanc"};
14. JComboBox listeDeroulante = new JComboBox(couleurs);
15.
16. c.add(listeDeroulante);
17. f.setVisible(true);
18. f.setDefaultCloseOperation(3);
19. }
20. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Une fenêtre dans laquelle on verra une liste déroulate. Comme ceci : Explications : La liste déroulante, appelée boite combo en java, est créée en instanciant un objet de la classe JComboBox. Le constructeur utilisé requiert forcément un argument de type tableau de String. La liste déroulante contient alors les chaines de caractères du tableau. |
Exemple 17 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre17
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. f.setVisible(true);
14. JOptionPane.showMessageDialog(f, "Bonjour !");
15. f.setDefaultCloseOperation(3);
16. }
17. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : Une fenêtre de titre "fenêtre java", dans laquelle on verra une deuxième fenêtre similaire à celle qu'on obtient grâce à la méthode alerte de l'objet Document du langage Javascript. Comme ci-dessous. cliquez pour voir le type de fenêtre en question La fenêtre en question (je parle de la deuxième fenêtre du programme exemple 17 ci-dessus), est appelée boîte de dialogue. Remarquez, en javascript aussi, c'est une fenêtre de dialogue. EN l'occurence, je dirais plutôt une fenêtre de monologue. Même si çs ne s'appelle pas ainsi, j'estime que c' est la bonne appelation. Puisque la fenêtre ne contient qu'un message à lire. Et aussi un bouton contenant le mot Ok. C' est donc un message d'alerte façon java. Vous en aurez besoin pour informer à l'utilisateur d'un programme, la suite des évènements. Outre le message Bonjour et le bouton Ok, la fenêtre de dialogue contient une image, je dirais plutôt une icone avec la lettre i. i comme information. Tant que vous ne cliquez pas sur le bouton Ok, vous ne pouvez pas avoir accès à la fenêtre graphique java. Revenons à l'explication du programme : La classe JOptionPane permet de créer ce type de fenêtre de dialogue. Pour cela, on utilise la méthode statique showMessageDialog() qui requiert 2 arguments (ligne 14). Le premier est un objet de type JFrame. C' est la fenêtre graphique sur laquelle doit apparaître la fenêtre de dialogue, encore appelée boite de message. Et le deuxième est une chaine de caractères qui est l'information à faire lire à l'utilisateur du programme. Remarque : Avant d'utiliser la méthode showMessageDialog(), vous devez d'abord faire apparaître la fenêtre graphique f. Sinon, y a des chances que la boite de message n'apparaisse pas sur la fenêtre graphique. Y a même de fortes chances que la fenêtre graphique apparaisse après avoir cliqué sur le bouton Ok de la boite de message. Comportement très logique. Pensez-y ! Pour que la boite de message apparaisse sur la fenêtre graphique, il est indispensable que l' instruction : f.setVisible(true); apparaisse avant l'instruction : JOptionPane.showMessageDialog(f, "Bonjour !"); Remarques très importantes : Le titre de la fenêtre de dialogue est Message. L' icone qui apparaît contient la lettre i. Ces deux choses apparaissent toujours par défaut. On peut les changer. Comment ? ... exemple suivant. |
Exemple 18 :
1. import javax.swing.*;
2. import java.awt.*;
3.
4. public class Fenetre18
5. {
6. public static void main(String [] args)
7. {
8. JFrame f = new JFrame("fenêtre java");
9. f.setSize(500, 250);
10. Container c = f.getContentPane();
11. FlowLayout miseEnFlot = new FlowLayout();
12. c.setLayout(miseEnFlot);
13. f.setVisible(true);
14. JOptionPane.showMessageDialog(f, "Attention, mauvaix choix", "Erreur", JOptionPane.ERROR_MESSAGE);
15. f.setDefaultCloseOperation(3);
16. }
17. }
|
|
Compilez puis exécutez ce programme. Il sera affiché : La même chose que ci-dessus. Sauf... Le titre de la fenêtre de dialogue a changé. Maintenant, c' est le mot Erreur qui est le titre. L' icone aussi a changé. Cette fois, nous avons un octagone orange contenant une croix rouge. Explications : Nous avons utilisé une variante de la méthode showMessageDialog(). Cette méthode est surdéfinie dans la classe JOptionPane. La version utilisée ici requiert 4 arguments. Le premier, c' est toujours l'objet fenêtre graphique sur lequel doit apparaître la fenêtre de dialogue. Le 2ème représente l'information (chaine de caractères) à lire sur la fenêtre de dialogue. Le 3ème, lui aussi une chaine de caractères représente le titre de la fenêtre graphique. Le 4ème représente l'affichage de l'icone de la fenêtre de dialogue. A ce propos, nous avons 4 types d'icônes qui sont : ERROR_MESSAGE --> représente un octagone orange avec croix rouge qu'on utilise généralement dans le cas où l'utilisateur où l'utilisateur n'a pas saisi la bonne information ou n' a pas cliqué au bon endroit. INFORMATION_MESSAGE ---> Représente un cercle bleu avec la lettre i en noir. C' est l'icone qui apparait par défaut lorsqu' on utilise la version de la méthode showMessageDialog() de l 'exemple 17. On l'utilise évidement pour une simple information à l'utilisateur du programme. WARNING_MESSAGE ---> Représente un triangle jaune à l' intérieur duquel on voit un point d'exclamation. On l'utilise pour avertir l'utilisateur. En général, c' est pour l' avertir sur la ou les conséquences d'une action de sa part dans la suite du programme. QUESTION_MESSAGE ---> Représente un carré dans lequel on trouve un point d'interrogation. Vous l'avez deviné. Pour poser une question. PLAIN_MESSAGE ---> pas d'icone. Peut être utilisé dans tous les autres cas. |
Il existe d'autres composants graphiques qu' on peut mettre dans une fenêtre graphique :
Autres infos : Sachez que parmi tous les composants graphiques, on distingue les composants atomiques. Ce sont les composants sur lesquels on ne peut pas mettre d'autres composants. Exemple : un bouton. Quel composant graphique peut-on mettre sur un bouton ? ... rien du tout. Il y a aussi les cases à cocher, les boutons radio. Les autres composants tels que la fenêtre, le conteneur, ne sont pas atomiques. |
| ← (précédent) D.0 Les interfaces graphiques (généralités) |
| D.2 Les bases de la programmation graphique : fenêtre Dynamique → |
| Accueil ↔ S O M M A I R E |
D.1 Les bases de la programmation graphique : |