Dans cette partie, nous aborderons les interfaces graphiques (on parle aussi

d'IHM pour Interfaces Homme Machine ou de GUI pour Graphical User Interfaces) et, par extension, la

programmation événementielle. Par là, vous devez comprendre que votre programme ne réagira plus à des
saisies au clavier mais à des événements provenant d'un composant graphique : un bouton, une liste, un
menu…

Le langage Java propose différentes bibliothèques pour programmer des IHM, mais dans cet ouvrage, nous
utiliserons essentiellement les packages javax.swing et java.awt présents d'office dans Java. Ce
chapitre vous permettra d'apprendre à utiliser l'objet JFrame, présent dans le package java.swing. Vous
serez alors à même de créer une fenêtre, de définir sa taille, etc.

Le fonctionnement de base des IHM vous sera également présenté et vous apprendrez qu'en réalité, une fenêtre
n'est qu'une multitude de composants posés les uns sur les autres et que chacun possède un rôle qui lui est
propre. Mais trêve de bavardages inutiles, commençons tout de suite !

 L'objet JFrame
 L'objet JPanel
 Les objets Graphics et Graphics2D

L'objet JFrame
Avant de nous lancer à corps perdu dans cette partie, vous devez savoir de quoi nous allons nous servir. Dans
ce cours, nous traiterons de javax.swing et de java.awt. Nous n'utiliserons pas de composants awt,
nous travaillerons uniquement avec des composants swing ; en revanche, des objets issus du
package awt seront utilisés afin d'interagir et de communiquer avec les composants swing. Par exemple, un
composant peut être représenté par un bouton, une zone de texte, une case à cocher, etc.

Afin de mieux comprendre comment tout cela fonctionne, vous devez savoir que lorsque le langage Java a vu
le jour, dans sa version 1.0, seul awt était utilisable ; swing n'existait pas, il est apparu dans la version 1.2 de
Java (appelée aussi Java 2). Les composants awt sont considérés comme lourds (on dit aussi HeavyWeight)
car ils sont fortement liés au système d'exploitation, c'est ce dernier qui les gère. Les composants swing, eux,
sont comme dessinés dans un conteneur, ils sont dit légers (on dit aussi LightWeight) ; ils n'ont pas le
même rendu à l'affichage, car ce n'est plus le système d'exploitation qui les gère. Il existe également d'autres
différences, comme le nombre de composants utilisables, la gestion des bordures…

Pour toutes ces raisons, il est très fortement recommandé de ne pas mélanger les
composants swing et awt dans une même fenêtre ; cela pourrait occasionner des conflits ! Si vous associez
les deux, vous aurez de très grandes difficultés à développer une IHM stable et valide. En
effet, swing et awt ont les mêmes fondements mais diffèrent dans leur utilisation.

Cette parenthèse fermée, nous pouvons entrer dans le vif du sujet. Je ne vous demande pas de créer un projet
contenant une classe main, celui-ci doit être prêt depuis des lustres ! Pour utiliser une fenêtre de
type JFrame, vous devez l'instancier, comme ceci :
 1import javax.swing.JFrame;
2
3public class Test {
4 public static void main(String[] args){
5 JFrame fenetre = new JFrame();
6 }
7}

Lorsque vous exécutez ce code, vous n'obtenez rien, car par défaut, votre JFrame n'est pas visible. Vous
devez donc lui dire « sois visible » de cette manière :

1import javax.swing.JFrame;
2
3public class Test {
4 public static void main(String[] args){
5 JFrame fenetre = new JFrame();
6 fenetre.setVisible(true);
7 }
8}

Ainsi, lorsque vous exécutez ce code, vous obtenez la figure suivante.

Première fenêtre

À toutes celles et ceux qui se disent que cette fenêtre est toute petite, je réponds : « Bienvenue dans le monde
de la programmation événementielle ! » Il faut que vous vous y fassiez, vos composants ne sont pas
intelligents : il va falloir leur dire tout ce qu'ils doivent faire.

Pour obtenir une fenêtre plus conséquente, il faudrait donc :

 qu'elle soit plus grande ;

 qu'elle comporte un titre (ce ne serait pas du luxe !) ;
 qu'elle figure au centre de l'écran, ce serait parfait ;
 que notre programme s'arrête réellement lorsqu'on clique sur la croix rouge, car, pour ceux qui ne
l'auraient pas remarqué, le processus Eclipse tourne encore même après la fermeture de la fenêtre.

Pour chacun des éléments que je viens d'énumérer, il y a aura une méthode à appeler afin que
notre JFrame sache à quoi s'en tenir. Voici d'ailleurs un code répondant à toutes nos exigences :

1import javax.swing.JFrame;
2
3public class Test {
4 public static void main(String[] args){
5
6 JFrame fenetre = new JFrame();
 7
8 //Définit un titre pour notre fenêtre
9 fenetre.setTitle("Ma première fenêtre Java");
10 //Définit sa taille : 400 pixels de large et 100 pixels de haut
11 fenetre.setSize(400, 100);
12 //Nous demandons maintenant à notre objet de se positionner au centre
13 fenetre.setLocationRelativeTo(null);
14 //Termine le processus lorsqu'on clique sur la croix rouge
15 fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
16 //Et enfin, la rendre visible
17 fenetre.setVisible(true);
18 }
19}

Voyez le rendu de ce code en figure suivante.

Une fenêtre plus adaptée

Afin de ne pas avoir à redéfinir les attributs à chaque fois, je pense qu'il serait utile que nous possédions notre
propre objet. Comme ça, nous aurons notre propre classe !

Pour commencer, effaçons tout le code que nous avons écrit dans notre méthode main. Créons ensuite une
classe que nous allons appeler Fenetre et faisons-la hériter de JFrame. Nous allons maintenant créer notre
constructeur, dans lequel nous placerons nos instructions. Cela nous donne :

1import javax.swing.JFrame;
2
3public class Fenetre extends JFrame {
4 public Fenetre(){
5 this.setTitle("Ma première fenêtre Java");
6 this.setSize(400, 500);
7 this.setLocationRelativeTo(null);
8 this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
9 this.setVisible(true);
10 }
11}

Ensuite, vous avez le choix : soit vous conservez votre classe contenant la méthode main et vous créez une
instance de Fenetre, soit vous effacez cette classe et vous placez votre méthode main dans votre
classe Fenetre. Mais dans tous les cas, vous devez créer une instance de votre Fenetre. Personnellement,
je préfère placer ma méthode main dans une classe à part… Mais je ne vous oblige pas à faire comme moi !
Quel que soit l'emplacement de votre main, la ligne de code suivante doit y figurer :

1Fenetre fen = new Fenetre();

Exécutez votre nouveau code, et… vous obtenez exactement la même chose que précédemment. Vous
conviendrez que c'est tout de même plus pratique de ne plus écrire les mêmes instructions à chaque fois. Ainsi,
vous possédez une classe qui va se charger de l'affichage de votre futur programme. Et voici une petite liste de
méthodes que vous serez susceptibles d'utiliser.

Positionner la fenêtre à l'écran

Nous avons déjà centré notre fenêtre, mais vous voudriez peut-être la positionner ailleurs. Pour cela, vous
pouvez utiliser la méthode setLocation(int x, int y). Grâce à cette méthode, vous pouvez spécifier
où doit se situer votre fenêtre sur l'écran. Les coordonnées, exprimées en pixels, sont basées sur un repère dont
l'origine est représentée par le coin supérieur gauche (figure suivante).

Coordonnées sur votre écran

La première valeur de la méthode vous positionne sur l'axe x, 0 correspondant à l'origine ; les valeurs positives
déplacent la fenêtre vers la droite tandis que les négatives la font sortir de l'écran par la gauche. La même règle
s'applique aux valeurs de l'axe y, si ce n'est que les valeurs positives font descendre la fenêtre depuis l'origine
tandis que les négatives la font sortir par le haut de l'écran.

Empêcher le redimensionnement de la fenêtre

Pour cela, il suffit d'invoquer la méthode setResizable(boolean b) : false empêche le

redimensionnement tandis que true l'autorise.

Garder la fenêtre au premier plan

Il s'agit là encore d'une méthode qui prend un booléen en paramètre. Passer true laissera la fenêtre au premier
plan quoi qu'il advienne, false annulera cela. Cette méthode est setAlwaysOnTop(boolean b).

Retirer les contours et les boutons de contrôle

Pour ce faire, il faut utiliser la méthode setUndecorated(boolean b).

Je ne vais pas faire le tour de toutes les méthodes maintenant, car de toute façon, nous allons nous servir de
bon nombre d'entre elles très prochainement.Cependant, je suppose que vous aimeriez bien remplir un peu
votre fenêtre. Je m'en doutais, mais avant il vous faut encore apprendre une bricole. En effet, votre fenêtre,
telle qu'elle apparaît, vous cache quelques petites choses !

Vous pensez, et c'est légitime, que votre fenêtre est toute simple, dépourvue de tout composant (hormis les
contours). Eh bien vous vous trompez ! Une JFrame est découpée en plusieurs parties superposées, comme le
montre la figure suivante.

Structure d'une JFrame

Nous avons, dans l'ordre :

  la fenêtre ;
 le RootPane (en vert), le conteneur principal qui contient les autres composants ;
 le LayeredPane (en violet), qui forme juste un panneau composé du conteneur global et de la barre
de menu (MenuBar) ;
 la MenuBar (en orange), la barre de menu, quand il y en a une ;
 le content pane (en rose) : c'est dans celui-ci que nous placerons nos composants ;
 le GlassPane (en transparence), couche utilisée pour intercepter les actions de l'utilisateur avant
qu'elles ne parviennent aux composants.

Pas de panique, nous allons nous servir uniquement du content pane. Pour le récupérer, il nous suffit d'utiliser
la méthode getContentPane() de la classe JFrame. Cependant, nous allons utiliser un composant autre
que le content pane : un JPanel dans lequel nous insérerons nos composants.

Il existe d'autres types de fenêtre : la JWindow, une JFrame sans bordure et non draggable (déplaçable), et

la JDialog, une fenêtre non redimensionnable. Nous n'en parlerons toutefois pas ici.

L'objet JPanel
Comme je vous l'ai dit, nous allons utiliser un JPanel, composant de type conteneur dont la vocation est
d'accueillir d'autres objets de même type ou des objets de type composant (boutons, cases à cocher…).

Voici le marche à suivre :

1. Importer la classe javax.swing.JPanel dans notre classe héritée de JFrame.

2. Instancier un JPanel puis lui spécifier une couleur de fond pour mieux le distinguer.
3. Avertir notre JFrame que ce sera notre JPanel qui constituera son content pane.

Rien de bien sorcier, en somme. Qu'attendons-nous ?

1import java.awt.Color;
2import javax.swing.JFrame;
3import javax.swing.JPanel;
4
5public class Fenetre extends JFrame {
6 public Fenetre(){
7 this.setTitle("Ma première fenêtre Java");
8 this.setSize(400, 100);
9 this.setLocationRelativeTo(null);
10
11 //Instanciation d'un objet JPanel
12 JPanel pan = new JPanel();
13 //Définition de sa couleur de fond
14 pan.setBackground(Color.ORANGE);
15 //On prévient notre JFrame que notre JPanel sera son content pane
16 this.setContentPane(pan);
17 this.setVisible(true);
18 }
19}
Vous pouvez voir le résultat à la figure suivante.

Premier JPanel

C'est un bon début, mais je vois que vous êtes frustrés car il n'y a pas beaucoup de changement par rapport à la
dernière fois. Eh bien, c'est maintenant que les choses deviennent intéressantes ! Avant de vous faire utiliser
des composants (des boutons, par exemple), nous allons nous amuser avec notre JPanel. Plus
particulièrement avec un objet dont le rôle est de dessiner et de peindre notre composant. Ça vous tente ?
Alors, allons-y !