Chapitre 5 : Interfaces

graphiques
 AWT et SWING: INTERFACES
GRAPHIQUES

PLAN PROGRAMMATION EVENEMENTIELLES

JDBC
AWT ET SWING INTERFACES
GRAPHIQUES
Interfaces graphiques
▪ L’une des préoccupation principales des concepteurs du langage a
été de fournir aux développeurs des moyens de mettre en place
facilement une interface au sein des applications:
GUI: Graphic User Interface
▪ Les interfaces homme machine ont pour finalité une interaction
rapide, facile et ergonomique entre l’utilisateur et la lignes de
commande afin de transcrire visuellement des informations vers et
depuis la machine (commandes, entrées/sortie, messages,
avertissements…)
▪ Une GUI est composée d’élément graphiques (composants).
Généralement interactifs (le but restant la communication homme-
machine)
Interfaces graphiques

▪ La programmation est dite « événementielle» car elle repose sur

l ’analyse des événements (click sur un bouton, choix dans une liste,
etc.) et sur l’implémentation des actions à effectuer lorsque l’un de
ces événements survient.
Interfaces graphiques
▪ Les possibilités offertes par java en terme d’interfaces graphiques
sont extrêmement importantes.
▪ Le langage fournit des éléments graphiques préexistants ainsi
que toutes les méthodes pour les gérer, les modifier ou faire de le
programmation événementielle.
▪ Il autorise également à créer ses propres éléments graphiques
▪ Enfin, il met à disposition des fonctionnalités plus générales
comme la possibilités de dessiner des formes.

▪ Il est conseiller de se référer le plus souvent possible au site d’Oracle

tant les bibliothèques graphiques sont conséquentes et complètes.
Interfaces graphiques
AWT est le premier essai des concepteurs de java pour offrir un
ensemble visant à la concepteur d’une GUI.

▪ AWT : Abstract Windowing Toolkit

▪ Les fenêtres, boutons et autres composants graphiques sont
construits autour de directives propres au système d’exploitation.
Les composants en jeu utilisent donc les ressources de l’OS:
composant dits « lourds»
A la différence d’AWT, les composants Swing sont des composants
«légers». Ils sont purement java (pas d’utilisation des directives du
système d’exploitation)
Interface graphiques
▪ Les composants Swing sont donc plus portables que les composants
AWT. Il sont également plus faciles à utiliser et plus robustes.

▪De Swing
plus, introduit
le packagela possibilité
AWT estdeindispensable
modifier le look and feel
pour des
l’utilisation des
composants:
gestionnaire de placement (layout) et pour les gestions d’événement.
Swing ne remplace
▪ C’est-à-dire donc pas
leur aspect totalement
général AWT(en
(couleurs, polices,revanche,
graphismes, il fournit
etc…).
uneSi nouvelle version
l’aspect par défaut plus légère et efficace
des composants deand
est le look presque tousil est
feel metal, les
composants,
tout à faittels les boutons,
possible panels,
de faire ets…)
en sorte que ces derniers affichent un
autre aspect ou le look général de l’OS sur lequel tourne l’application.
▪ Les composants AWT restent tout de même utilisés, notamment
dans les applets (on utilise de plus en plus des JApplets construites à
partir de Swing).
Interface graphique
▪ D’une manière générale, on distingue d’un point de vue syntaxique
les composants swing des composant AWT par un «J» placé en
début de nom.
▪ Ainsi, le button de AWT possédé son équivalent swing Jbutton,
Panel devient Jpanel, etc…
▪ Un import de package est nécessaire pour utiliser les éléments de
AWT et/ou de swing:
▪ Import java.awt.*; //pour les composants AWT, ainsi que les
gestionnaires de placement.
▪ Import javax.swing.*; //pour les composants swing (ne pas
oublier le x de javax
Composants graphique
Des composants de
haut nivaux, ou
On distingue deux types de

containers,
principalement
Exemples: Frame et
destinés à recevoir
Jframe, Panel et JPanel
composants:

eux-mêmes d’autre
composants et des
Container
gestionnaires de
placement
Composant

Des composants de
niveaux inférieurs Exemples: Button et
typiquement les Jbutton, checkBox et
composants usuels JCheckBox, TextField et
disposés au sein des JTextField
containers.
Composant graphiques: les containers

▪ Les containers les plus utilisés les Frame et les Panel (et leurs
homologues en swing).
▪ Hiérarchies de classes: la classe Container possède plusieurs sous
classes, dont window, Panel et ScrollPane. De Window sont dérivées
les classes Frame (et sa sous classe Jframe) et Dialog (et ses sous
classes FileDialog et Jdialog entre autre). Enfin il est noter que de
Panel est dérivée la classe Applet(et sa sous classe JApplet).
▪ Un ScrollPane est un container avec barres de défilement
(ascenseurs)
Composant graphiques: les containers

▪ Comme elles héritent de window, Frame et Dialog instancient des

fenêtres (en fait des cadres et des boites de dialogue).ainsi une
Frame et une fenêtre
▪ Ces classes fenêtre gèrent notamment les barres de titre et de menu
▪ A noter qu’a la différence des autre composants Swing, les
Containers JWindow, JFrame, JDialog et JApplets ne sont pas pur
java: ils dérivent de Window(java.awt) et utilisent par conséquent le
système natif de fenêtre de l’OS
Composant graphiques
Jframe: Constructeurs et méthodes (non exhaustif):
▪ Jframe()
▪ Jframe(String titre)
▪ String getTitle()
▪ Void setTitle(String title) // fixe le titre de la fenêtre
▪ Void setResizable(boolean b) // rend la fenêtre redimensionnable
▪ Boolean isRsizable(boolean b)
▪ Void pack() //réduit la fenêtre a la taille de ses composants
▪ Void show() // rend la fenêtre visible(sinon, hide)
▪ Void toFront() //place la fenêtre au premier plan
▪ Void toBack() // place la fenêtre en dessous des autres
▪ Void repaint() //rafraichissement de la fenêtre
 Composants graphique
Les composants ils sont très variés
▪ Button et Jbutton: bouton a presser. Il est possible de fixer leur
texte, mais également de leur attribuer une image de fond
▪ Label et Jlabel: étiquette texte non modifiable par l’utilisateur de
https://docs.oracle.com/en/java/java-components/index.html
l’interface graphique
▪ TextField et JTextField: texte d’une ligne sur lequel peut agir
l’utilisateur affichage ou saisies d’informations
▪ TextArea et JTextArea: idem mais plusieurs lignes
▪ CheckBox et JCheckBox: case a cocher (boolean)
▪ RadioBox et JRadioBox : ensemble de cases dans lequel un seul
choix est possible à la fois
▪ JProgressBar: barre de progression
Composant graphique
Quelque méthodes:
▪ Jbutton:
Jbutton()
Jbutton(String texte)
Jbutton(Icon icone) //avec ImageIcone icone = createImageIcon(image/logo,gif)
Jbutton(String texte, Icon icon)
Boolean isDefaultButton()
void setText(String texte)
▪ JLabel:
Jlabel(String texte)
Jlabel(Icon image)
void setText(String Texte)
String getText()
Composant graphique
▪ JTextField:
JTextField ()
JTextField (String texte)
JTextField (int colonne)
getText() et setText(String texte)

▪ JCheckBox:
JCheckBox()
JCheckBox(String texte)
JCheckBox(String texte, Icon icone, boolean select)
void setSelected(boolean b)
boolean isSelected()
Composant graphique
▪ JComboBox:
JComboBox ()
JComboBox (Object[] tab) // ComboBox avec les éléments contenu
//dans le tableau tab
JComboBox (Vector v) // Idem avec vecteur
void addItem(Object obj)
Object getItemAT (int indice)
Int getItemCount()
int getSelectedIndex() // retourne l’indice de l’élément sélectionné
Object getSelectedItem() // retourne l’élément sélectionné
void setSelectedIndex(int indice) //sélectionne l’élément à l’indice
//indice
void setSelectedItem(Object obj) //fixe l’élément à la position
//courante
Composant graphique
▪ JList:
JList ()
JList (Object[] tab) // liste avec les éléments contenu dans le
//tableau tab
JList (Vector v) // Idem avec un vecteur
Object getSelectedValue() //retourne l’élément selectionné sinon
//null
Object [] getSelectedValues() // retourne les éléments selectionné
▪ JSlider:
Jslider()
Jslider(int min, int max, int defaut) //slider entre m et n positionné
//à defaut
int getValue() //retourne la valeur du curseur
void setValue(int n) //positionne le curseur
Composant graphique

La manière de coder des interfaces graphique est toujours la même:

▪ Création d’un ou plusieurs container (au moins une fenêtre)

▪ Implémentation d’un composant
▪ Ajout d’un composant à un container
▪ Implémentation d’un composant

Ne pas oublier de rendre la fenêtre visible!

Interface graphique
De manière plus précise, avec des composants AWT, il suffit de créer
une frame, puis un composant et d’ajouter le second à la première via
une méthode add()
Interface graphique
Il est également possible de travailler sur un Panel au lieu d’ajouter les
composants directement sur la fenêtre:
Interface graphique
Autre manière de coder: faire hériter la classe de Frame
Les objets instancier sont donc sortes de fenêtre, alors que dans les cas
précédents ils implémentaient une fenêtre.
Interface graphique
Dans le cas de l’emploi des composants swing, la manière de procéder
est similaire. L’héritage utilisé dans l’exemple précédent est également
possible (en faisant hériter la classe de Jframe et non de Frame).

Cependant, quelques points sont à souligner:

▪ Les composants ne sont évidemment pas les mêmes. Ne pas oublier

que leurs noms commencent par un «J».
▪ Le package à importer n’est bien entendu pas le même non plus.
Interface graphique
Gestionnaire de placement
La disposition des composant de bas niveau au sein de l’espace offert
par une frame, un panel ou une fenêtre en général peut se décider de
manière totalement « manuelle », par un système de coordonnées.
Cependant, java met à disposition des développeurs des gestionnaires
de placement prédéfinies permettant de gagner du temps et des
efforts(layout).
Ils autorisent un placement des composants suivant des logiques
spécifiques et sont généralement suffisants pour obtenir l’aspect désiré
pour l’application développée
Ils permettent souvent des ajustements afin de peaufiner leur utilisation
et d’optimiser les résultats obtenus
Gestionnaire de placement
Un gestionnaire s’applique à un container. Mais il peut par la suite lui-
même contenir d’autre containers sur lesquels on s’applique également
des gestionnaire pour y placer des composants complexes et fines
Cinq gestionnaires de placement principaux peuvent être cités:
• BorderLayout
• FlowLayout
• GridLayout
• CardLayout
• GridBagLayout
Les trois premier gestionnaire sont les plus rencontrés et les plus faciles
à utiliser. Les deux suivants sont plus facilement gérables via des
environnements de développement, mais il est tout à fait possible de le
coder manuellement
Gestionnaire de placement
Frame ou Jframe(avec une
JMenuBar(Barre de menu, optionnelle)
JMenuBar eventuelement

Panel ou Jpanel (dans le

ContentPane en Swing)

Gestionnaire de placement

Autres composants
(Button/Jbutton,
TextField/JTextField, etc
Gestionnaire de placement: BorderLayout

North

West Center East

South
Gestionnaire de placement

Le BorderLayout

▪ C’est le gestionnaire par défaut des Frame

▪ Il divise le Container sur lequel il est appliqué en 5 zones(North,
South, East, West et Center). Les composants qui sont placés dans
ces zones (un par zone) y occupent l’ensemble de la place disponible.
Chacun peut elle-même contenir un container sur lequel on peut
appliquer un BorderLayout(découpage très fin)
Gestionnaire de placement
Constructeurs et méthodes (non exhaustif)
▪ BorderLayout() //contructeur par defaut
▪ BorderLayout(int h, int v) // crée un BorderLayout au sein
duquel les composant sont séparés par un espace horizontal h et un
espace vertical v
▪ Void LayoutContainer(Container cont) //applique le
gestionnaire container
▪ Void addLayoutComponent(String p, Component c)
//ajoute le composant c à la position p (qui peut être North, South,
East, West ou Center)
▪ Void removeLayoutComponent(Component c) //retire le
composant c
Gestionnaire de placement: FlowLayout

1ere 2eme
composant 3eme

4eme 5eme 6eme

Gestionnaire de placement

Le FlowLayout

▪ C’est le gestionnaire par défaut des Panels et applets

▪ Il dispose les composants les uns à la suite des autres, en lignes, et
change de ligne lorsqu’il atteint le bord du container il fait une retour
a la ligne.
▪ Constantes: CENTER, LEFT et RIGHT sont trois entiers indiquant
que les composants disposés sur une ligne sont soit à centrer soit à
aligner à gauche, soit à aligner à droite.
Gestionnaire de placement
Constructeurs et méthodes (non exhaustif)

▪ FlowLayout() //contructeur par defaut(lignes centrées et

espacement verticaux et horizontaux en 5 pixels entre les
composants)
▪ FlowLayout(int alignement) // crée un gestionnaire dont
l’alignement est choisi par l’utilisateur ( CENTER,LEFT ou
RIGHT)
▪ FlowLayout(int alignement, int h, int v) //alignement de
type alignement et espacements horizontal h et vertical v entre les
composants
Gestionnaire de placement: GridLayout

1ére
composant 2eme 3eme

4eme 5eme 6eme

Gestionnaire de placement

Le GridLayout

▪ Il divise le container en un nombre donné de cases identiques. Un

composant par case
Constructeurs et méthodes (non exhaustif)

▪ Public GridLayout(int rows, int cols) //gestionnaire de

placement de rows lignes et cols colonnes. Les espacements entre
les composants est de 0px (vertical et horizontal)
▪ Public GridLayout(int rows, int cols, int h, int v)
//espacement horizontal h et vertical v entre les composants
Gestionnaire de placement

Le CardLayout

▪ N’affiche qu’un composant à un moment donné. Les différents

composants sont considérés empilés comme dans un jeu de cartes
 Gestionnaire de placement
Constructeurs et méthodes (non exhaustif)
▪ CardLayout() //constructeurs par défaut
▪ CardLayout(int h, int v) //espacement horizontal h et vertical v entre les
composants
▪ Void first(Container cont) //affiche le premier des composants cont est
les container sur lequel est appliqué le gestionnaire de placement
▪ Void next(Container cont) //affiche le composant suivant cont est le
container sur lequel est appliqué le gestionnaire de placement
▪ Public void previous(Container cont) //affiche le composant
précèdent cont est le container sur lequel est appliqué le gestionnaire de
placement
▪ Public void show(Container cont , String n) //affiche le composant
associé à la chaine n cont est le container sur lequel est appliqué le
gestionnaire
Gestionnaire de placement

Le GridBagLayout

▪ C’est le gestionnaire de placement le plus sophistiqué et flexible.

Il permet une disposition fine des composants en proposant la
mise en place d’une grille. A la différence du GridLayout les cases
de la grille peuvent avoir des dimensions variables. De plus les
composants peuvent occuper plus d’une case.
Gestionnaire de placement
Le BoxLayout

▪ Il dispose les composants les uns au dessus des autres, sur une
seule colonne. Il permet les alignements.

1ere

2eme

3eme
Gestionnaire de placement
Principe général d’utilisation (exemple avec deux
BorderLayout):

Définir le container

Construire le gestionnaire et l’appliquer au container via

la méthode setLayout()

Disposer les composants dans le container grâce au

gestionnaire
Gestionnaire de placement
PROGRAMMATION EVENEMENTIELLE
Gestion des événements
Une fois l’interface graphique créée, il convient d’implémenter le
comportement de l’application face aux événements(actions appliquées
sur les composants)
Par exemple, que doit il se passer lorsque l’on clique sur l’un des
boutons? Lorsque l’on effectue un choix dans une liste?
Il est nécessaire d’importer java.awt.event.*;
• Pour cela, il est nécessaire de préciser l’intêret que porte un
composant a un type d’événement (ou a plusieurs)

Java permet ainsi, de ne s’interesser qu’aux types d’evenements désirés

pour un composant donné(sans avoir a traiter tous les types
d’événements existants pouvant potentiellement être gérés par ce
composant)
Gestion des événements
La logique générale de gestion d’événements est asse simple:

• Des objets (en général des composants) sont sources d’événements.

Par la on entend qu’ils sont a l’écoute d’événements (clic, choix, etc)
et qu’il provoquent en réponse l’instanciation d’un objet événement
(Event)
• Par exemple, un bouton est en attente d’un clic. Si ce dernier se
produit, un objet événement est créé
• D’autre objets sont écouteurs d’événements c’est-à-dire qu’ils sont en
attente d’un objet événement. Ces objets écouteurs sont des
instances de classes implémentant des interfaces Listeners
(écouteurs)
 Gestion des événements
Ecouteurs :
ActionListener,
MouseListener,…

Source de
Evénements :
l’événement :
ActionEvent,
JButton,
MouseEvent,…
JRadioButton,…

Traitement

Des
événements La Machine
L’utilisateur sont propagés Virtuelle reçoit
interagit avec tous ces
événements
l’IHM
Seuls ceux qui
sont ‘écoutés’
sont transmis
 Principe
• Un composant peut générer certains évènements
• Un objet évènement reflète une action de l'utilisateur (clic, passage souris, redimensionnement de
la fenêtre, etc.)
• La gestion de l'évènement est déléguée à un écouteur d'évènements qui active le traitement
associé selon le type d’évt (Action, Key, Mouse listener)

événement

écouteur

Composant
 Gestion des événements
Exemple: un bouton n’a d’autre utilisé que d’être pressé. Lorsque l’on
clique sur un Jbuton b1 (événement). Quelque chose doit se
passer(affichage à l’ecran, par exemple).

La gestion des événements se déroule selon un mécanisme très précis

• Il faut en premier préciser qu’un composant source porte de l’intérêt

à un type d’événement. Pour cela on utilise sur ce composant une
méthode addXXXXListener(…) ou XXX représente un type
d’événement. En argument de cette méthode doit être précisé un
élément écouteur qui est susceptible de connaitre la manière de
réagir face à l’événement
Gestion des événements
▪ Il faut donc également coder le fait qu’un élément du programme
(une classe) puisse être intéressé par le fait que l’événement attendu
par le composant soit produit . Pour cela cette classe (écouteuse) doit
implémenter l’interface xxxListener et va contenir une méthode
xxxaction (xxxEvent). Cette dernière attend un xxxEvent (objet
Event crée par le composant source lorsque l’événement survient) et
elle indique ce qu’il se passe lorsque l’événement de départ survient
▪ Si l’événement survient (ex: clic) et qu’il concerne ce composant
source (ex: bouton) un objet de type xxxEvent est instancié. Celui-ci
est capturé par un objet de la classe écouteuse qui implémente
l’interface xxxListener. La méthode xxxaction de l’objet écouteur est
alors appelée.
Gestion des événements: exemple
1- Prenons une interface graphique contenant uniquement un JButton
Gestion des événements: exemple
2- Nous voulons provoquer un affichage à l’écran lorsque le bouton b est
pressé. Il faut donc préciser que b est à l’écoute des événements de type
« clic » qui le concernant
Gestion des événements

3- B est abonné aux événements de type Action. Lorsque un événement

de ce type va concerner b (clic) un objet de type ActionEvent va être
instancié. B est donc source de l’objet événement (Event). Ce dernier
contient des informations, comme l’objet source dé sa création

A noter que la source d’un objet xxxEvent peut être obtenu via la
méthode getSource() qui retourne un objet de type Object(il faut
généralement utiliser un cast)
 Gestion des événements
4- Cet objet doit être traité par une méthode actionPerformed() qui
indique la réaction face à l’événement. Donc une classe doit coder cette
méthode. Pour cela le classe en question doit implémenter l’interface
ActionListener. Le fait d’implémenter cette interface implique deux
choses: les instances de cette classe sont en attente d’objets
ActionEvent( donc d’événement de type Action) et la classe doit coder la
méthode actionPerformed(). Ce dernier point est obligatoire car les
méthodes d’une interface sont abstraites

• Si une classe implémente cette dernière, elle doit en redéfinir les

méthodes
Gestion des événements

• Il faut donc:
• Qu’une classe implémente l’interface. Dans le cas présent notre
seule classe est Appli. Nous allons donc faire en sorte qu’elle soit
à l’écoute des événements gérées par son propre bouton.
• Au niveau de l’abonnement du bouton b pour les événement de
type Action (méthode addActionListener), indiquer un élément
susceptible de gérer l’objet ActionEvent créé.cet élément est une
instance de la classe implémentant l’interface ActionListener et
donc, ce sera l’objet courant (this) car c’est le seul objet crée.
Gestion des événements
• Java propose de nombreux composants , donc de très nombreux
types d’événements pouvant être traités.
• Un composant peut être abonné à plusieurs types d’événements, une
classe peut implémenter plusieurs interfaces (et donc plus leurs
méthodes permettant de gérer plusieurs types d’événements).
• Tous les composants est toujours identiques. Pour un type
d’événement xxx, nous avons:
• Une interface xxxListener
• Un type d’objet événement xxxEvent
• Une méthode xxxaction attendant comme argument un objet
xxxEvent.
 Gestion des événements
Interface écouteur description Composant qui génére
l’événement
ActionListener Ecoute les actions de l’utilisateur : clics, barre JButton,
d’espacement, entrée • JButton, JRadioButton JRadioButton,
et JCheckBox : clic gauche et barre
d’espacement • JComboBox : déplacement dans
JCheckBox
la zone déroulante avec les flèches de JComboBox,
déplacement • JTextField : touche Entrée JTextField
AdjustmentListener Ajustement d’une barre de défilement JScrollBar

ComponentListener Déplacement, affichage, masquage ou Component

modification de la taille de composants

ContainerListener ContainerListener Ajout ou suppression Container

d'un composant dans un conteneur
 Gestion des événements
Interface écouteur description Composant qui génére
l’événement
FocusListener Obtention ou perte du focus par un composant Component

ItemListener Sélection d’un élément dans un Checkbox,JComboBox,

combobox ou dans une liste (mais pas List, JRadioButton…
avec Jlist) ou dans un groupe de cases à
cocher
KeyListener Ecoute les KeyEvents : actions sur les Component
touches du clavier (pressée ou relâchée)

DocumentListener Changement ou insertion dans un Document

document
 Gestion des événements
Interface écouteur description Composant qui génére
l’événement
ListSelectionListener Ecouteur qui notifie quand la sélection JList,JTable,…
d’éléments dans une liste change (L’utilisateur
sélectionne (désélectionne) un item ou
plusieurs items dans une JList,une JTable,…)
TextListener Changement sur une zone de texte JTextField

WindowListener Action sur la fenêtre (fenêtre activée, Window

désactivée, réduite, fermée, …)

MouseListener Action sur la souris (clic sur un bouton Component

de la souris: appuyer, relâcher, etc.)
 Gestion des événements
Interface Méthodes de traitements Méthode d’enregistrement
écouteur
ActionListener actionPerformed(ActionEvent e) addActionListener()

AdjustmentListener adjustmentValueChanged(adjustmentEv addAdjustmentListener

ent e) ()
ComponentListener componentHidden(ComponentEvent e) addComponentListener
componentMoved(ComponentEvent e) ()
componentResized(ComponentEvent e)
componentShown(ComponentEvent e)
ContainerListener componentAdded(ContainerEvent e) addContainerListener()
componentRemoved(ContainerEvent e)
 Gestion des événements
Interface Méthodes de traitements Méthode d’enregistrement
écouteur
FocusListener focusGained(FocusEvent e) addFocusListener()
focusLost(FocusEvent e)
ItemListener itemStateChanged(ItemEvent e) addAdjustmentListener
()
KeyListener keyPressed(KeyEvent e) addKeyListener()
keyReleased(KeyEvent e)
keyTyped(KeyEvent e)
DocumentListener changedUpdate(DocumentEvent e) addDocumentListener()
insertUpdate(DocumentEvent e)
removeUpdate(DocumentEvent e)
 Gestion des événements
Interface écouteur Méthodes de traitements Méthode d’enregistrement

ListSelectionListener valueChanged (ListSelectionEvent e) addListSelectionListener()

WindowListener windowActivated(WindowEvent e) addWindowListener()

windowClosed(WindowEvent e)
windowClosing(WindowEvent e)
windowDeactivated(WindowEvent e)
windowDeiconified(WindowEvent e)
windowIconified(WindowEvent e)
windowOpened(WindowEvent e)
WindowListener windowActivated(WindowEvent e) addWindowListener()
windowClosed(WindowEvent e)
windowClosing(WindowEvent e)
windowDeactivated(WindowEvent e)
windowDeiconified(WindowEvent e)
windowIconified(WindowEvent e)
windowOpened(WindowEvent e)