Université Abderrahmane Mira de Bejaia
Faculté des Sciences Exactes
Département d’informatique
Année universitaire : 2023/2024
2ème Année Ingénieur Informatique (S4) Module : Programmation Orientée Objet
TP 2 (Interfaces graphiques)
Objectif
L’objectif de cette série est de concevoir des interfaces graphiques en java. Il n’est pas demandé d’utiliser
les bases de données à ce niveau (TP3).
Rappels de cours
1. Généralités :
La construction d'interfaces graphiques en Java repose sur un système à base de fenêtres. Deux
bibliothèques de composants d'interfaces (boutons, fenêtre de listes, boîtes combo, cases à cocher etc.) sont
disponibles. La plus ancienne porte le nom de AWT (A… Windowing Toolkit) et a jeté les bases du système
de fenêtrage.
Le système le plus récent est né d'une collaboration entre Sun et Netscape et porte le nom de SWING.
Swing est une surcouche posée sur AWT (la plupart des classes de Swing dérivent des classes d'AWT) qui
apporte de nombreuses améliorations :
• Richesse fonctionnelle et de présentation supplémentaires
• Nouveau modèle de gestion des événements
• Modèle Document / Instance pour la création de composants
• Modèle Document / Vue pour les composants d'affichage de données
2. Les bases de construction d'une interface graphique
Une interface graphique est basée sur 2 grandes composantes différentes :
• L'aspect visuel qui comprend les cadres et les composants d'interfaces qui sont placés dessus
• L'interaction avec les utilisateurs (action de la souris, du clavier) c'est à dire en fait la gestion des
événements.
La programmation visuelle s'appuie sur le concept de fenêtre cher aux environnements
modernes. Toute programmation graphique s'appuie sur un conteneur global. Celui-ci peut
être :
• Une fenêtre cadre
• Une fenêtre de dialogue
• Une applet
Les deux premiers types sont assez semblables car ils sont généraux à tout type de système
fenêtré. Par exemple, sous Windows, une fenêtre cadre correspond à la fenêtre principale d'une
application.
• Les composants visuels
• Les composants
• Tout composant visuel descend plus ou moins directement de la classe
• La gestion des événements
Les événements sont des objets spéciaux qui sont générés par les actions de l'utilisateur (un clic
de souris par exemple) ou par le système lui-même (une défaillance du système de fichier).
Dr H. EL BOUHISSI TP 2 - (Interfaces graphiques) Page 1/6
Par défaut, ils sont placés dans la file d'événements (events queue). Certains événements sont
gérés par le système lui-même alors que les autres doivent être pris en compte par l'utilisateur.
La file des messages a une taille limitée qui fait que les événements les plus anciens et qui
n'ont pas été traités sont détruits afin de laisser la place aux événements les plus récents.
Il y a deux grands moyens pour gérer les événements :
1. Le programme va lui-même pécher un événement dans la file et établit une réponse
appropriée. Il a alors la possibilité de retirer l'événement s'il juge sa réponse suffisante
ou bien de le laisser dans la file de manière à ce qu'il soit à nouveau géré par un
mécanisme automatique du système.
2. Le programme met en place des objets spécialisés dits écouteurs d'événements
spécialisés dans le traitement d'un type particulier d'événement (par exemple le
déplacement de la souris) et associés à un élément d'interface précis (une fenêtre par
exemple). Le système redirige alors les événements idoines vers une méthode
particulière de l'objet.
3. Les listeners
Ce sont des objets spécialisés dans le traitement des événements. Comme explicité ci-dessus,
ils doivent implémenter des interfaces particulières qui leur permettent de traiter les
événements.
Chaque interface est associée à un grand type d'événements. Par exemple, l'interface
java.awt.event.ActionListener correspond aux événements de type Commande (clicker sur un
bouton, activer un menu etc.). Cette interface contient la méthode :
void actionPerformed(ActionEvent e)
Cette méthode est destinée à être redéfinie dans la classe de votre objet Listener. Elle sera
appelée automatiquement lorsque l'utilisateur cliquera sur un bouton par exemple. On ajoute un
objet listener à un élément d'interface à l'aide d'une méthode addXXXListener ou XXX dénote
le type d'événement traité. Les éléments suivants sont à prendre en compte :
• Un même objet peut répondre à différents types d'événements pour peu qu'il implémente les
interfaces adéquates
• Un même objet peut être le listener de plusieurs sources
• Une même source peut avoir autant de listeners que de types d'événements qu'elle peut générer.
• On peut même connecter plusieurs listeners sur le même type d'événements de la même source. Ils
seront appelés dans l'ordre inverse de leur ajout
4. Gestion des événements :
Ce mécanisme de gestion comporte trois éléments : la source de l'événement (e.g. un
bouton), l'objet de l'événement et l'écouteur d'événement. Pour spécifier qu'un événement vient
de se produire, la source envoie un objet événementiel à l'écouteur qui pourra l'utiliser pour
répondre à l'événement.
Pour gérer un événement, le programmeur doit inscrire un écouteur d'événement (souvent à
l'aide de la méthode addActionListener) et définir un gestionnaire d'événement (dont le nom est
passé comme paramètre à addActionListener). Par exemple, un clic sur un bouton sera géré de
la manière suivante :
Jbutton bouton = new Jbutton("Bouton");
ButtonHandler gestionnaire = new ButtonHandler();
bouton.addActionListener(gestionnaire);
Dr H. EL BOUHISSI TP 2 - (Interfaces graphiques) Page 2/6
Dans cet exemple, la classe ButtonHandler (qui constitue le gestionnaire d'événement) doit être
définie par le programmeur et doit implémenter l'interface ActionListener. La méthode
actionPerformed de cette interface doit dès lors être définie :
class ButtonHandler implements ActionListener {
public void actionPerformed(ActionEvent evenement) { ... }
}
Parmi les types d'événements, on retrouve ActionEvent, MouseEvent, KeyEvent, ItemEvent, etc.
À chacun de ces événements est associé un écouteur correspondant et de nom semblable (e.g.
ActionListener <> ActionEvent). La documentation de la classe java.awt.Event permet d'avoir
plus d'informations sur les différents types d'événements et écouteurs utilisables en Java.
5. Notion d'adaptateurs
Nous avons vu au cours qu'une classe implémentant une interface doit redéfinir toutes les
méthodes présentes dans l'interface. Or, il arrive parfois que l'on souhaite n'utiliser que l'une ou
l'autre des méthodes de l'interface écouteur.
On voudra alors éviter de devoir définir toutes les méthodes de cette interface ce qui sera rendu
possible par les adaptateurs.
Un adaptateur fournit une implémentation par défaut pour toutes les méthodes de l'interface
écouteur de nom semblable (e.g. à l'écouteur MouseListener correspond un adaptateur nommé
MouseAdapter).
Le programmeur peut alors hériter de la classe adaptateur et ne surcharger que les méthodes
qui lui sont réellement utiles.
Remarque : toutes les méthodes par défaut d'un adaptateur ont un corps vide, c'est-à-dire
qu'elles n'ont aucune action particulière.
Voici quelques composants de javax.swing :
Activités
Activité 1
Réaliser l’application suivante :
Dr H. EL BOUHISSI TP 2 - (Interfaces graphiques) Page 3/6
• Le bouton « ajouter » permet de faire la somme de Nombre 1 et Nombre 2, le résultat est
mis dans la zone du résultat.
• Le bouton Effacer permet de vider les champs Nombre1, Nombre2 et Résultat.
• Le bouton Quitter permet de fermer l’application.
On donne à titre indicatif :
Conversion d’un type primitif en une chaîne
String chaine = String.valueOf(valeur);
de caractères
Activité 2
Le but de cet exercice est de réaliser un convertisseur graphique Euros/Dollars. Avec les
fonctionnalités suivantes :
• Si l’utilisateur entre une valeur dans la case euros et
valide (touche entrée) alors le montant correspondant en
dollars est calculé et affiché dans la case correspondante,
de plus une flèche => est affichée pour indiquer le sens de
la conversion.
• De même avec la case euros (et une flèche <=).
• L’utilisateur doit aussi pouvoir changer le taux de change
à l’aide des flèches d’un bouton JSpinner (voir image ci-dessous).
• Enfin, si l’utilisateur ferme la fenêtre ou clique sur quitter l’exécution du programme se
termine.
• Les saisies erronées seront traitées par des exceptions.
Activité 3
L’objectif de cette activité est de familiariser le développeur
avec swing pour Java, en développant une calculatrice capable
de réaliser les opérations mathématiques simples.
Dans ce TP nous allons illustrer : La conception d’un écran
graphique en utilisant différents layoutManagers et
l’implantation des mécanismes de gestion des événements
utilisateurs.
Activité 4
On souhaite obtenir l’interface suivante, comportant : un
bouton de choix (de la classe Choice), une liste (de la classe List), un bouton (de la classe
Button) et un champ de texte (de la classe TextArea).
Dr H. EL BOUHISSI TP 2 - (Interfaces graphiques) Page 4/6
Soit un code source partiel de l’image ci-dessus :
import java.awt.* ;
class Fenetre extends Frame {
protected Panel p ;
protected Choice c ;
protected List l ;
protected Button suite ;
protected TextArea texte ;
Fenetre() { // le constructeur
p = new Panel() ;
c = new Choice() ;
... // ajout des items dans l’objet Choice
p.add(c) ;
l = new List(5) ;
... // ajout des items dans l’objet List
p.add(l) ;
... // création du bouton suite
p.add(suite) ;
add("North", p) ;
texte = new TextArea();
... // remplissage du champ de texte
add("South", texte) ;
} }
public class UtilAwt {
public static void main(String args[]) {
Fenetre f = new Fenetre() ;
f.pack() ; f.show() ;
}
}
• Compléter le constructeur Fenetre() afin d’aboutir au résultat escompté en suivant les instructions mises
en commentaires.
Activité 5
Réaliser la fenêtre d’authentification suivante. Le bouton Connexion permet d’afficher une boite de
dialogue de salutations. Le bouton Créer un compte permet d’afficher les informations (Username et
Password) sur une nouvelle fenêtre.
Activité 6
Réaliser l’interface suivante. Le remplissage du tableau se fait via une fenêtre (des labels et zones de textes).
Dr H. EL BOUHISSI TP 2 - (Interfaces graphiques) Page 5/6
Activité 7
Réaliser la fenêtre suivante (sans évènements).
L2 Ingénieur 2023-2024
Activité 8
Réaliser les interfaces suivantes : un clic sur ok de la fenêtre 1, permet d’ajouter les informations sous forme
de tableaux à lecture seule (semblable à l’activité 6).
Activité 9
Réaliser un menu général pointant toutes les activités ci-dessus. Chaque activité doit être présentée dans un
jframe, avec un bouton quitter de chaque activité et du menu global. La conception est laissée à
l’appréciation des étudiants
Dr H. EL BOUHISSI TP 2 - (Interfaces graphiques) Page 6/6
