23/05/2022

Généralités sur les interfaces graphiques

Interface avec l’utilisateur
• La quasi-totalité des programmes informatiques
nécessitent:
Chapitre : ▫ l’affichage de questions posées à l’utilisateur
Les interfaces graphiques en JAVA ▫ l’entrée de données par l’utilisateur
▫ l’affichage des résultats obtenus par le traitement
informatique
• Cet échange d’informations peut s’effectuer avec une
interface utilisateur (UI en anglais) en mode texte
(ou console) ou en mode graphique

Généralités sur les interfaces graphiques API utilisées pour les interfaces
graphiques en Java
Interface Graphique
Les API
• Une interface graphique est formée d’une ou plusieurs
fenêtres qui contiennent divers composants graphiques
• bibliothèques :
(widgets) tels que ▫ AWT (Abstract Window Toolkit, JDK 1.1)
▫ boutons ▫ Swing (JDK 1.2)
▫ listes déroulantes • Swing et AWT font partie de JFC (Java Foundation
▫ menus Classes) qui offre des facilités pour construire des
▫ champ texte interfaces graphiques
▫ etc. • Swing est construit au-dessus de AWT
• Les interfaces graphiques sont souvent appelés GUI d’après ▫ même gestion des événements
l’anglais Graphical User Interface.
▫ les classes de Swing héritent des classes de AWT
Interface Programme
Humain
Homme/Machine Métier

1
 23/05/2022

API utilisées pour les interfaces API utilisées pour les interfaces
graphiques en Java graphiques en Java
Swing ou AWT ? Swing ou AWT ?
• AWT (Abstract Window Toolkit) • Tous les composants de AWT ont leur équivalent dans
▫ Composants graphiques « lourds » Swing
▫ Chaque composant est relié à son équivalent dans ▫ En plus joli
l’OS par un « peer » ▫ avec plus de fonctionnalités
▫ Look & Feel dépendant de l’OS
• Swing offre de nombreux composants qui n’existent
• SWING pas dans AWT
▫ Nouveau package ▫ Il est fortement conseillé d’utiliser les composants Swing
▫ Composants graphiques « légers », en pur Java
▫ Tous les composants sont détachés de l’OS
▫ Look & Feel indépendant de l’OS Swing est plus lourd et plus lent que AWT

API utilisées pour les interfaces Composant et hiérarchie

graphiques en Java de composants
Structure de l’AWT
• L’AWT offre trois types d’éléments graphiques
 AWT et Swing utilise des classes différentes pour représenter
▫ Les « Containers » (contenants)
chaque composant graphique. ▫ Les « Components » (composants ou contenus)
 Tous les composants ont une classe racine commune (cette ▫ Les « LayoutManagers » (disposition des objets d’un contenant)

classe n'est pas abstraite !!)

• La classe représentant les composants est :
▫ pour l'AWT : Component
▫ pour Swing : Jcomponent
• Notons que tous les noms des composants graphiques de
Swing commence par J...

2
 23/05/2022

Composant et hiérarchie Composant et hiérarchie

de composants de composants: AWT
Structure de l’AWT Les « Components »
Les « Containers » • Héritage de méthodes:
Sont destinés à accueillir des composants ▫ paint(Graphics g) : Affiche le composant
▫ repaint() : Rafraîchit l’affichage du composant
Gèrent l’affichage des composants
(rappelle la méthode paint)
Ex: Frame, Panel, Window ▫ getGraphics() : Crée un contexte graphique pour le
Les « Components » composant
Constituent différents éléments de l’affichage (boutons, barres de ▫ Etc. voir documentation Java en ligne
menus, etc.) • Composants de formulaires (exemples)
Ex: Button, Canvas, Label, Scrollbar, Checkbox ▫ Button (bouton)
Les « LayoutManagers » ▫ CheckBox (case à cocher)
Gèrent la disposition des composants au sein d’un conteneur. ▫ Label (case de texte)
• Composants de fenêtre (exemples)
▫ Menu (Menu d’une barre de menus)
▫ MenuItem (Elément d’un menu)

Composant et hiérarchie Composant et hiérarchie

de composants: AWT de composants: AWT
Les « Containers » Les « LayoutManagers »
• Héritage de méthodes: • Rôle
▫ add(Component c) : Intègre le composant spécifié à la fin du ▫ Gérer la disposition des composants au sein d’un conteneur
container
▫ setLayout(LayoutManager l) : Configure le LayoutManager du • Types principaux:
container ▫ BorderLayout: divise le conteneur en 5 zones
▫ Etc. voir documentation Java en ligne ▫ FlowLayout: rajoute les composants au fur et à mesure
▫ GridLayout: applique une grille au conteneur pour aligner les composants
• La classe « Frame »
▫ CardLayout: pour un conteneur qui contient plusieurs cartes
▫ Composant du plus haut niveau
▫ GridBagLayout: grille de cellules élémentaires
▫ La fenêtre d’une application est une instance de cette classe
▫ Le Frame contient les différents composants graphiques de
l’application
▫ Ne peut être intégré dans un autre conteneur
• Les classes « Panel », « Window », « ScrollPane », etc.
▫ Contenants essentiels
▫ Peuvent être intégrés au sein d’un Frame

3
 23/05/2022

Composant et hiérarchie Composant et hiérarchie

de composants : AWT de composants : AWT
HelloWorld avec AWT Hiérarchie de composants
• Le programme affiche une fenêtre ayant pour titre « Bonjour AWT ».  Les composants sont organisés sous la forme d'un arbre

import java.awt.Frame;

public class HelloAWT {

public static void main(String[] args) {
Frame frame = new Frame();
frame.setTitle("Bonjour AWT");
frame.setSize(400,300);
frame.setVisible(true);
}
}

Notons que s'il on clique sur la croix, la fenêtre devient non

visible mais l'application continue.

Composant et hiérarchie Composant et hiérarchie

de composants : AWT de composants : AWT
Hiérarchie de composants Hiérarchie de composants
 La méthode add() permet d'ajouter un composant à un container
 Panel est un sous-type de Container Chaque composant possède un
import java.awt.*;
état indiquant s'il est visible ou public class Hierarchy {
public static void main(String[] args) {
import java.awt.*; non (is/setVisible()) Button bouton1=new Button("bouton 1");
public class Hierarchy {
Button bouton2=new Button("bouton 2");
public static void main(String[] args) { Un changement d'état de la
Button bouton1=new Button("bouton 1");
Panel panel=new Panel();
Button bouton2=new Button("bouton 2"); visibilité se propage sur panel.add(bouton1);
panel.add(bouton2);
Panel panel=new Panel(); l'ensemble des composants fils
panel.add(bouton1); Frame frame=new Frame("Bonjour AWT");
panel.add(bouton2); du composant. frame.add(panel);
frame.setSize(400,300);
Frame frame=new Frame("Bonjour AWT");
frame.setVisible(true);
frame.add(panel);
}
frame.setSize(400,300); Les composants Frame, Dialog, }
frame.setVisible(true);
} Window, Applet possédent
}
aussi la méthode setVisible()

4
 23/05/2022

Composant et hiérarchie Composant et hiérarchie

de composants de composants
Relation entre Swing et AWT Relation entre Swing et AWT
• Swing utilise l'AWT pour ouvrir une fenêtre
• Il y a deux types de composants Swing
▫ les heavyweight : gérés par l'AWT, correspondent à des
fenêtres de la plateforme : JFrame, JDialog, JWindow,
JApplet
▫ les lightweight : composants Java qui effectuent le
dessin
• Tous les composants AWT sont heavyweights

Composant et hiérarchie Composant et hiérarchie

de composants : SWING de composants : SWING
HelloWorld avec Swing Composants de Swing
• Le programme affiche une fenêtre ayant pour titre «Bonjour Swing ». • Les composants de Swing partagent une partie de leur implantation avec
ceux de l'AWT
import javax.swing.JFrame;
public class HelloSwing { • Il y a beaucoup plus de composants Swing que de composants AWT
public static void main(String[] args)
{
JFrame frame = new JFrame();
frame.setTitle("Bonjour Swing");
frame.setSize(400, 300);
frame.setVisible(true);
}
}

Notons que s'il on clique sur la croix, l'application ne se

ferme toujours pas.

5
 23/05/2022

Composant et hiérarchie Les fenêtres

de composants : SWING
Composants de Swing • Il existe plusieurs types de fenêtres dans Swing :
• Problème de design n'importe quel JComponent est un Container
• Le code suivant est donc possible :
import javax.swing.*;

public class PbDesign {

public static void main(String[] args) {
JFrame frame=new JFrame();

JButton bouton1=new JButton("bouton 1");

JButton bouton2=new JButton("bouton 2");
bouton1.add(bouton2);

frame.setContentPane(bouton1);
frame.setTitle("Bonjour Swing");
frame.setSize(400,300);
frame.setVisible(true);
}
}

Les fenêtres Les fenêtres

• Swing propose deux types de fenêtres : JWindow et JFrame. JWindow

▫ Composants proches et descendent Window (AWT). • La fenêtre la plus basique.
• Constructeur est appelé pour créer une fenêtre • C'est juste un conteneur que vous pouvez afficher sur votre écran.
• Par défaut, une fenêtre crée n’est pas affichée • Il n'a pas de :
▫ La méthode setVisible permet d’afficher une fenêtre. ▫ barre de titre, boutons de fermeture / redimensionnement, et n'est pas
redimensionnable par défaut.
• La taille d’une fenêtre dépend des éléments qu’elle contient.
• Vous pouvez bien sûr lui ajouter toutes ces fonctionnalités.
• Pour éviter d’estimer ou de la calculer la taille, Swing propose une
méthode (pack) qui calcule la taille de la fenêtre en fonction de la taille • On utilise surtout les JWindow pour faire des SplashScreen, c'est-à-dire
préférée de ses composants internes. des interfaces d'attente qui se ferment automatiquement.
• Lors de l’appel de la méthode pack, la méthode getPreferredSize est import javax.swing.JWindow;

appelée sur tous les composants pour connaître leurs dimensions. public class TestJWindow {
▫ Ces informations sont utilisées pour calculer la dimension de la fenêtre. public static void main(String[] args) {
JWindow fenetre = new JWindow();
• La méthode setLocation permet de positionner le composant à fenetre.setSize(300, 300);
l’intérieur du conteneur. fenetre.setLocation(300, 300);
fenetre.setVisible(true);
• L’écran est le conteneur des JFrame et des JWindow }
}

6
 23/05/2022

Les fenêtres Les fenêtres

JFrame JFrame
• C'est une fenêtre destinée à être la fenêtre principale de votre
application.
• Elle n'est dépendante d'aucune autre fenêtre et ne peut pas être import javax.swing.JFrame;

modale. public class TestJFrame {

public static void main(String[] args) {
• La plupart des applications sont construites à partir d’une (ou JFrame fenetre = new JFrame();
plusieurs) JFrame. fenetre.setSize(300, 300);
fenetre.setVisible(true);
➔ En effet, JFrame construit des fenêtres qui comportent une fenetre.setLocation(500, 500);
}
bordure, un titre, des icônes et éventuellement un menu. }
• La position des icônes et la police du titre dépend donc du système.
• Par contre, l’icône représentant la fenêtre lorsqu’elle est réduite
peut être modifié en utilisant la méthode setIconImage.
Exemple 1(Jframe) document Exemples-GUI

Les fenêtres Les fenêtres

JFrame JFrame
• la méthode setLocation(int x, int y): spécifier où Une Jframe est découpée en plusieurs parties superposées:
doit se situer votre fenêtre sur l'écran. Les coordonnées, la fenêtre La MenuBar
exprimées en pixels, sont basées sur un repère dont l'origine
Le RootPane
est représentée par le coin supérieur gauche.
Le GlassPane
Le LayeredPane

le content pane

• La méthode setResizable(boolean b):false empêche

le redimensionnement tandis que true l'autorise.
Conteneur principal qui contient les autres composants.
• setAlwaysOnTop(boolean b):true laissera la fenêtre
Forme juste un panneau composé du conteneur global et de la barre de menu .
au premier plan.
C'est dans celui-ci que nous placerons nos composants ;
Couche utilisée pour intercepter les actions de l'utilisateur avant qu'elles ne parviennent aux composants.

7
 23/05/2022

Les fenêtres Les fenêtres

Utilisations du contentPane
JFrame JFrame
• Il est possible :
• Une JFrame contient une fille unique, de la - de demander le contentPane (getContentPane())
classe JRootPane - de changer de contentPane (setContentPane())
• Cette fille contient deux fils, glassPane JFrame
(JPanel) et layeredPane import java.awt.*; import javax.swing.*;
import javax.swing.*;
(JLayeredPane) JRootPane
public class HierarchySwing2 {
public class HierarchySwing {
• La layeredPane a deux fils, contentPane public static void main(String[] args) {
(un Container) et menuBar (un public static void main(String[] args) {
JButton button1 = new JButton("button 1");
glassPane JlayeredPane
JMenuBar) JFrame frame=new JFrame("HelloSwing"); JButton button2 = new JButton("button 2");
Container c=frame.getContentPane();
• On travaille dans contentPane. c.setLayout(new FlowLayout()); Jpanel panel = new JPanel();
panel.add(button1);
• JApplet, JWindow et JDialog utilisent contentPane menuBar JButton button1=new JButton("button 1"); panel.add(button2);

aussi un JRootPane. c.add(button1);

JButton button2=new JButton("button 2"); JFrame frame = new JFrame("HelloSwing");
c.add(button2); frame.setContentPane(panel);

frame.setSize(400,100); frame.setSize(400, 100);

frame.setVisible(true); frame.setVisible(true);
} }
} }

Les fenêtres Les fenêtres

Utilisations du contentPane Interface graphique et programmation objet
JFrame JFrame
• Java est un langage Objet, il est donc
• Normalement, l'ajout de composants possible d'utiliser l'héritage.
se fait sur le contentPane et non sur • Doit-on hériter par exemple de la
la JFrame import java.awt.*; classe JFrame ?
import javax.swing.*;
• Mais, si l'on effectue un add() sur
une JFrame : public class HierarchySwing3 {
public static void main(String[] args) {
import javax.swing.*;

▫ En 1.4 et avant, il y a une erreur à public class MorphSwing1 {

JFrame frame=new JFrame("HelloSwing");
l'exécution frame.setLayout(new FlowLayout());
public static void main(String[] args) {
JButton button=new JButton("Ok");
▫ En 1.5, est équivalent à JButton button1=new JButton("button 1");
JPanel panel=new JPanel();
panel.add(button);
getContentPane().add() frame.add(button1);
JFrame frame=new JFrame("Fenêtre Swing sans Héritage");
JButton button2=new JButton("button 2");
• Ce mécanisme marche pour les frame.add(button2);
frame.setContentPane(panel);
frame.setSize(400,300);
méthodes : frame.setSize(400,100);
}
frame.setVisible(true);

add/remove/setLayout }
frame.setVisible(true);
}
}

8
 23/05/2022

Les fenêtres Les fenêtres

Interface graphique et programmation objet Interface graphique et programmation objet
JFrame JFrame
• On hérite d'une classe si on veut en changer les fonctionnalités
• Java est un langage Objet, il est donc
(i.e. redéfinir une méthode)
possible d'utiliser l'héritage.
➔Il est possible de faire des fonctions pour rendre le code plus clair.
• Doit-on hériter par exemple de la
classe JFrame ? import javax.swing.*;
public class MorphSwing3 extends JPanel{
• OUI public MorphSwing3() {
super();
import javax.swing.*;
JButton button=new JButton("Ok");
public class MorphSwing2 extends JFrame { this.add(button);
public MorphSwing2() { }
super("Fenêtre Swing avec Héritage"); JFrame créer(String title) {
JButton button=new JButton("Ok"); JFrame frame = new JFrame(title);
JPanel panel=new JPanel(); frame.setContentPane(this);
panel.add(button);
setContentPane(panel);
frame.setSize(400, 300);
setSize(400,300); frame.setVisible(true);
setVisible(true); return frame; }
} public static void main(String[] args) {
public static void main(String[] args) { new MorphSwing3().créer("Fenêtre Swing avec
new MorphSwing2(); Héritage : Fonction de création ");
}
}
}
}

Les fenêtres Les fenêtres

Pluggable Look & Feel Pluggable Look & Feel
JFrame JFrame
• Swing sépare les composants de leur rendu. • Swing sépare les composants de leur rendu.
• Il est ainsi possible de changer le look d'un ensemble de composants. • Il est ainsi possible de changer le look d'un ensemble de composants.
▫ Windows : com.sun.java.swing.plaf.windows.WindowsLookAndFeel ▫ Windows : com.sun.java.swing.plaf.windows.WindowsLookAndFeel
▫ Motif : com.sun.java.swing.plaf.motif.MotifLookAndFeel ▫ Motif : com.sun.java.swing.plaf.motif.MotifLookAndFeel
▫ Metal : javax.swing.plaf.metal.MetalLookAndFeel ▫ Metal : javax.swing.plaf.metal.MetalLookAndFeel
▫ GTK : com.sun.java.swing.plaf.gtk.GTKLookAndFeel ▫ GTK : com.sun.java.swing.plaf.gtk.GTKLookAndFeel

try {
UIManager.setLookAndFeel(className);
} catch (UnsupportedLookAndFeelException e) {
...
} catch (Exception e) {
...
}
SwingUtilities.updateComponentTreeUI(frame);
frame.pack();

try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");}
catch(Exception e) { e.printStackTrace(); }

9
 23/05/2022

Les fenêtres Les info bulles

Fermeture de fenêtre
JFrame JToolTip
• Par défaut, en cliquant sur la croix d'une fenêtre, l'application n'est pas arrêtée. • Tous les composants dérivant de JComponent peuvent être agrémentés d’info-
• setDefaultCloseOperation() permet de spécifier un comportement bulles :
• Comportements : ➔petites boites contenant un texte qui présente le rôle du contrôle.
▫ DO_NOTHING_ON_CLOSE • En pratique, il n’est pas nécessaire d’instancier un objet.
▫ HIDE_ON_CLOSE (défaut) ➔La classe JComponent propose une méthode qui permet de créer directement
▫ DISPOSE_ON_CLOSE le composant JToolTip et de l’associer au composant.
▫ EXIT_ON_CLOSE
import javax.swing.*;
import javax.swing.*; public class ExempleJToolTip extends JFrame {
public class FermerFrame extends JFrame { public ExempleJToolTip() {
public static void main(String[] args) { JButton button = new JButton("Bouton");
JButton button = new JButton("Ok"); button.setToolTipText("Exemple d’info-bulles");
JPanel panel = new JPanel(); JPanel panel=new JPanel();
panel.add(button); panel.add(button);
JFrame frame = new JFrame("Fermeture de la Fenêtre"); getContentPane().add(panel);
frame.setContentPane(panel); setSize(300, 100);
frame.setSize(400, 300); setVisible(true);
frame.setVisible(true); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); public static void main(String args[]) {
} } new ExempleJToolTip();}}

Les bordures Les boites de dialogues

Bordure • Swing propose des boites de dialogues afin de communiquer rapidement

• Les composants peuvent être encadrés par une bordure souvent utilisée pour avec l’utilisateur.
matérialiser des blocs d’informations • La classe JOptionPane permet de créer des boites de dialogues
• La classe BorderFactory fournit de nombreuses méthodes statiques pour créer
génériques mais aussi modifiable en fonction des besoins de l’application.
des bordures prédéfinies.
• Les méthodes d’affichage sont statiques
import javax.swing.*;
public class Bordure extends JFrame{ ➔il n’est donc pas nécessaire d’instancier une classe pour les utiliser.
public Bordure() {
JButton button = new JButton("Bouton");
JPanel panel=new JPanel();
panel.add(button);
panel.setBorder(BorderFactory.createTitledBorder("Une bordure"));
setTitle("Exemple Bordure");
setSize(300, 100);
setVisible(true);
setContentPane(panel);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new Bordure();
}
}

10
 23/05/2022

Les boites de dialogues Les boites de dialogues

Les messages de dialogue Les messages de dialogue

• Informent l’utilisateur en affichant un texte simple et un bouton de
• On peut modifier l’aspect de la fenêtre en fonction du type de message.
confirmation.
• Exemple : Afficher un dialogue d’avertissement .
• On peut aussi afficher un icône correspondant au message (point
d’exclamation, symbole d’erreur,...). import javax.swing.JFrame;
• Pour afficher un message on utilise la méthode showMessageDialog de import javax.swing.JOptionPane;
la classe JOptionPane. public class MsgDialogue2 {
public static void main(String[] args) {
import javax.swing.JFrame; JFrame frame = new JFrame();
import javax.swing.JOptionPane; JOptionPane.showMessageDialog(frame, "Problème de réseau",
"Connexion au réseau impossible.", JOptionPane.WARNING_MESSAGE);
public class MsgDialogue1 { System.exit(0);
public static void main(String[] args) { }
JFrame frame = new JFrame(); }
JOptionPane.showMessageDialog(frame, "Message de dialogue");
System.exit(0);
}
}

Les boites de dialogues Les boites de dialogues

Les messages de dialogue Les messages de dialogue

Les dialogues de confirmation/question Les dialogues de confirmation/question
• Les boites de dialogues peuvent aussi être utilisées pour demander un • La boite de dialogue renvoie un entier en fonction du choix de l’utilisateur et peut
renseignement à l’utilisateur. être utilisé pour modifier le comportement du programme.
▫ Le cas le plus courant est une question fermée. • Cet entier est définit comme une constante de la classe JOptionPane.
• La méthode showConfirmDialog affiche ce type de boite. import javax.swing.*;

import javax.swing.JFrame; public class MsgDialogue4 {

import javax.swing.JOptionPane; public static void main(String[] args) {
JFrame frame = new JFrame();
public class MsgDialogue3 { int rep = JOptionPane.showConfirmDialog(frame, " Aimez vous Java ? ",
public static void main(String [] args) { " Exemple Msg (Yes or NO) ", JOptionPane.YES_NO_OPTION);
JFrame frame=new JFrame(); if (rep == JOptionPane.YES_OPTION) {
JOptionPane.showConfirmDialog(frame, "Choisir une réponse"); // ...
System.exit(0); }
} if (rep == JOptionPane.NO_OPTION) {
} // ...
}
System.exit(0);
}
}

11
 23/05/2022

Les boites de dialogues Les boites de dialogues

Les messages de dialogue Les messages de dialogue

Les dialogues de saisie Construction de dialogues personnalisés
• Pour construire des boites de dialogue plus complexes on utilise la méthode
• La méthode showInputDialog affiche une boite de dialogue comprenant une
showOptionDialog.
entrée de saisie (JTextField) en plus des boutons de validation.
• Cette méthode admet 8 paramètres (certains pouvant être à null).
• Après validation elle retourne une chaîne de caractères (String) si l’utilisateur a
cliqué sur OK, sinon elle renvoie null. • Elle renvoie un entier qui correspond au bouton qui a été cliqué.
import javax.swing.*;
import javax.swing.JFrame; public class MsgDialogue6{
import javax.swing.JOptionPane; public static void main(String[] args) {
JFrame frame = new Jframe();
public class MsgDialogue5 { JLabel labelNom = new JLabel("Nom :");
public static void main(String[] args) { JLabel labelPrenom = new JLabel("Prenom :");
JFrame frame = new Jframe(); JTextField nom = new JTextField();
String rep = JOptionPane.showInputDialog(frame, "Entrez votre nom d'utilisateur"); JTextField prenom = new JTextField();
System.exit(0); JLabel lab = new JLabel("Entrez vos nom et prénom ");
} Object[] tab = new Object[] { labelNom, nom, labelPrenom, prenom, lab };
} int rep = JOptionPane.showOptionDialog(frame, tab, "Saisie des nom et prenom ",
JOptionPane.OK_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE, null, null, null);
System.exit(0);
}
}

Les conteneurs secondaires Les conteneurs secondaires

Le panneau : JPanel
• Swing propose de nombreux conteneurs secondaires pour créer des
interfaces ergonomiques.
• Le conteneur léger le plus simple de Swing et le panneau
➔des composants légers.
(JPanel), c’est le conteneur par défaut de JFrame et de
• Il est possible d’en créer d’autre à l’aide des méthodes de programmation
orientée objets. JWindow.
• La plupart des interfaces possibles dans les systèmes d’exploitation usuels • Permet de grouper des composants selon une politique de
sont présentes comme par exemple les panneaux à onglets, les panneaux placement.
défilant,. . .
• Pour ajouter un composant à un panneau, on utilise la
méthode add (ou l’une de ses surcharges).
• La méthode réciproque remove permet d’enlever un
composant.

12
 23/05/2022

Les conteneurs secondaires Les conteneurs secondaires

Le panneau : JPanel Le panneau a défilement : JScrollPane

import javax.swing.*;
public class FicheIdentite extends JPanel {
• Les applications traitant du texte ou des images n’affichent
private JTextField nom; souvent qu’une partie du document pour éviter de monopoliser
private JLabel labelNom;
private JTextField prenom;
toute la surface d’affichage.
private JLabel labelPrenom; ▫ Des ascenseurs sont affichées sur les cotés afin de pouvoir se
déplacer dans le document.
public FicheIdentite() {
super(); ▫ Le composant JScrollPane permet d’implémenter cette fonction.
labelNom = new JLabel(" Nom : ");
labelPrenom = new JLabel(" Prénom : "); import javax.swing.*;
nom = new JTextField(5); public class TestScrollPane {
prenom = new JTextField(5); public static void main(String[] args) {
this.add(labelNom); JFrame frame = new JFrame();
this.add(nom); JLabel monImage = new JLabel(new ImageIcon("Koala.jpg"));
this.add(labelPrenom);
JScrollPane lePanneau = new JScrollPane(monImage);
this.add(prenom);
} frame.setContentPane(lePanneau);
public static void main(String[] args) { frame.setTitle("Image de Koala");
JFrame frame = new JFrame("JPanel Exemple"); frame.setSize(400, 400);
frame.setSize(300, 100); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setContentPane(new FicheIdentite()); frame.setResizable(false);
frame.setVisible(true);
frame.setVisible(true);
}
} }
}

Les conteneurs secondaires Les conteneurs secondaires

Le panneau divise : JSplitPane Le panneau a onglets : JTabbedPane

• Le composant JTabbedPane permet de construire des interfaces en utilisant des onglets.
• Séparer une interface en deux volets est utilisé pour mettre en
vis-à-vis deux documents, ou un document et une barre d’outils. • Les composants peuvent ainsi être regroupés de manière thématique pour obtenir des
interfaces allégées.
• La séparation peut être horizontale ou verticale selon les
• La méthode addTab permet d’ajouter un composant dans une nouvelle feuille.
interfaces.
• Généralement on utilise le plus souvent JPanel comme conteneur.
• Ce type d’interface fait appel au JSplitPane.
import javax.swing.*; public class MenuOnglets extends JTabbedPane {
private FicheIdentite identite;
public class TestSplitPane {
private FicheIdentite etudes;
public static void main(String[] args) {
public MenuOnglets() {
JFrame frame = new JFrame("JSplitPane exemple"); identite = new FicheIdentite();
JTextArea source = new JTextArea(); etudes = new FicheIdentite();
JTextArea traduction = new JTextArea(); this.addTab("Identité", identite);
JSplitPane lePanneau = new this.addTab("Etudes ", etudes);
JSplitPane(JSplitPane.HORIZONTAL_SPLIT, }
source, traduction); public static void main(String[] args) {
frame.setContentPane(lePanneau); JFrame frame = new JFrame("JTabbedPane exemple");
frame.setSize(400, 200); JPanel panel = new JPanel();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); panel.add(new MenuOnglets());
frame.setResizable(false); frame.setContentPane(panel);
frame.setSize(300, 120);
frame.setVisible(true);
frame.setVisible(true);
}
}
} }

13
 23/05/2022

Les conteneurs secondaires Les conteneurs secondaires

Les barres d’outils : JToolBar Les bureaux JDesktopPane

• Les applications complexes font souvent appel à des barres d’outils pour pouvoir accéder • De nombreuses applications autorisent l’ouverture de plusieurs
facilement aux fonctions les plus utilisées.
documents simultanément.
• Swing propose un conteneur (JToolBar) pour construire des barres d’outils regroupant
n’importe quel composant. ▫ Ces interfaces sont nommées MDI (Multiple Document Interface).
import javax.swing.*; • Le composant JDesktopPane propose une implémentation de ce
public class JToolBarreExemple {
public static void main(String[] args) { comportement.
JFrame frame = new JFrame("JTabbedPane exemple");
JButton bOuvrir = new JButton(new ImageIcon("openfile.png"));
▫ permet d’afficher des fenêtres (JInternalFrame) à l’intérieur de
JButton bEnregistrer = new JButton(new ImageIcon("savefile.png"));
JButton bCouper = new JButton(new ImageIcon("editcut.png"));
l’application.
JButton bCopier = new JButton(new ImageIcon("editcopy.png")); • Les fenêtres JInternalFrame proposent des méthodes proches de
JButton bColler = new JButton(new ImageIcon("editpaste.png"));
bOuvrir.setToolTipText("Ouvrir un fichier"); celles de JFrame (bien qu’il n’existe pas de relation d’héritage).
bEnregistrer.setToolTipText("Enregistrer le fichier");
bCouper.setToolTipText("Couper vers le presse - papier"); • Pour des application MDI, une classe fille est souvent crée à partir de
bCopier.setToolTipText("Copier vers les presse - papier");
bColler.setToolTipText("Coller depuis le presse - papier");
JInternalFrame.
JToolBar tb = new JToolBar(); tb.add(bOuvrir); tb.add(bEnregistrer);
tb.addSeparator(); tb.add(bCouper); tb.add(bCopier); tb.add(bColler);
frame.setContentPane(tb); frame.setSize(300, 80);
frame.setVisible(true);
}
}

Les conteneurs secondaires Les conteneurs secondaires

Les bureaux JDesktopPane Les bureaux JDesktopPane

import javax.swing.*; import javax.swing.*;
public class TestDesktop extends JDesktopPane {
public class FrameMDI extends JInternalFrame { FrameMDI[] animaux;
public FrameMDI() { String[] nomsFichier = { "cheval.jpg", "tigre.jpg", "vache.jpg" };
super("", true, true, true, true); public TestDesktop() {
} animaux = new FrameMDI[3];
public void setImage(String nomImage) { for (int i = 0; i < 3; i++) {
JPanel unPanneau = new JPanel(); animaux[i] = new FrameMDI();
JLabel uneImage = new JLabel(new ImageIcon(nomImage)); animaux[i].setSize(200, 200);
unPanneau.add(uneImage); animaux[i].setLocation(100 * i, 50 * i);
this.setContentPane(unPanneau); animaux[i].setImage(nomsFichier[i]);
this.setTitle(nomImage); animaux[i].setVisible(true);
} this.add(animaux[i]);
} }
}
public static void main(String[] args) {
JFrame frame = new JFrame();
frame.setContentPane(new TestDesktop());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
frame.setSize(450, 350);
frame.setTitle("Afficheur d’images");
}}

14
 23/05/2022

Les composants atomiques Les composants atomiques

Les labels : JLabel

• Un label est une simple chaîne de caractères
• Les composants atomiques sont tous les informative (il peut aussi contenir une image).
composants élémentaire de Swing. • Pour créer un nouveau label il suffit d’appeler le
• Ce sont les boutons, les labels, les menus,. . . constructeur JLabel.
import javax.swing.*;
public class TestJLabel {
public static void main(String[] args) {
JFrame fen = new JFrame();
JPanel pan = new JPanel();
JLabel unLabel = new JLabel("Une chaine de caractères");
pan.add(unLabel);
fen.setContentPane(pan);
fen.pack();
fen.setVisible(true);
}
}

Les composants atomiques Les composants atomiques

Les labels : JLabel Les boutons : JButton et JToggleButton

• JLabel peut afficher aussi un objet ImageIcon. • Les boutons sont les composants les plus utilisés pour interagir avec
▫ Il suffit alors de créer un objet ImageIcon à partir de l’image à l’utilisateur.
afficher et d’associer cet icône à un JLabel.
• Le constructeur de ImageIcon permet de charger directement • Swing propose plusieurs types de boutons.
un fichier de type JPEG, GIF ou PNG en passant le nom du • Tous les boutons héritent de la classe abstraite AbstractButton qui
fichier en paramètre lors de l’appel du constructeur. fournit de nombreuses méthodes pour paramétrer les boutons.
• Tous les boutons peuvent être accompagnés d’un texte (setText).
import javax.swing.*;
public class TestJLabelImage { • Les descendants de AbstractButton peuvent être décorés à l’aide
public static void main(String[] args) { d’icônes (setIcon).
JFrame fen = new JFrame();
JPanel pan = new JPanel(); • La méthode setMnemonic permet de définir une touche de raccourcis
ImageIcon img = new ImageIcon("cheval.jpg");
JLabel unLabel = new JLabel ( img );
pour le clavier (combinaisons ALT + touche).
pan . add ( unLabel );
fen.setContentPane(pan);
fen.pack();
fen.setVisible(true); monBouton.setText("Un bouton");
} monBouton.setMnemonic(KeyEvent.VK_B);
}

15
 23/05/2022

Les composants atomiques Les composants atomiques

Les boutons : JButton Le composant JToggleButton

• Le bouton le plus utilisé est le JButton. • Swing propose un type de bouton particulier, les boutons à bascule :
• Crée un bouton qui peut être cliqué par l’utilisateur à l’aide de la JToggleButton.
souris. • Ces boutons conservent leur état après le relâchement de la souris.
import javax.swing.*;
import javax.swing.*; public class TestJToggleButton {
public class TestJButton { public static void main(String[] args) {
public static void main(String[] args) { JFrame fen = new JFrame();
JFrame fen = new JFrame(); JPanel pan = new JPanel();
JPanel pan = new JPanel(); JLabel unLabel = new JLabel("Un label");
JLabel unLabel = new JLabel("Un label"); ImageIcon img = new ImageIcon("openfile.png");
JButton unBouton1 = new JButton("Un Bouton 1"); JToggleButton unBouton = new JToggleButton("Un Bouton", img);
ImageIcon img = new ImageIcon("openfile.png"); pan.add(unLabel);
JButton unBouton2 = new JButton("Un Bouton 2", img); pan.add(unBouton);
pan.add(unLabel); fen.setContentPane(pan);
pan.add(unBouton1); fen.pack();
pan.add(unBouton2); fen.setVisible(true);
fen.setContentPane(pan); }
fen.pack(); }
fen.setVisible(true);
}
}

Les composants atomiques Les composants atomiques

Les cases a cocher : JCheckBox Les boutons radio : JRadioButton

• Les cases à cocher permettent de matérialiser des choix binaires • Les boutons radio JRadioButton sont des boutons à choix exclusif, il
d’une manière plus usuelle que les boutons à bascules permettent de choisir un (et un seul) élément parmi un ensemble.
(JToggleButton.) Comme les boutons, elles héritent de la classe
abstraite AbstractButton. import javax.swing.*;
public class TestJRadioButton {
public static void main(String[] args) {
import javax.swing.*; JFrame fen = new JFrame();
JPanel pan = new JPanel();
public class TestJCheckBox { JRadioButton plat1, plat2, plat3;
ButtonGroup plat;
plat1 = new JRadioButton(" Saussice et lentilles");
public static void main(String[] args) {
plat2 = new JRadioButton(" Boeuf bourguigon");
JFrame fen = new JFrame(); plat3 = new JRadioButton(" Gratin de fruits de mer ");
JPanel pan = new JPanel(); plat = new ButtonGroup();
JCheckBox casePasCochee = new JCheckBox( "Une case à cocher") ; plat.add(plat1); plat.add(plat2);
JCheckBox caseCochee = new JCheckBox("Une case coché" , true ); plat.add(plat3); pan.add(plat1);
pan.add(casePasCochee); pan.add(plat2);
pan.add(caseCochee); pan.add(plat3);
fen.setContentPane(pan); pan.setBorder(BorderFactory.createTitledBorder("Plat du jour"));
fen.pack(); fen.setContentPane(pan);
fen.setVisible(true); fen.pack();
} fen.setVisible(true);
} }
}

16
 23/05/2022

Les composants atomiques Les composants atomiques

Les listes de choix : JList Les boites combo : JComboBox

• JList permet de choisir un (ou plusieurs) élément(s) parmi un ensemble • Les boites combo permettent de choisir un seul élément parmi une liste
prédéfini. proposée.
• Cet ensemble peut être un tableau ou vecteur d’objets quelconques. • Elles ont un comportement proche des boutons radio.
import javax.swing.*; • On les utilise quand l’ensemble des éléments à afficher n’est pas connu lors
public class TestJList { de la conception.
public static void main(String[] args) { import javax.swing.*;
public class TestJComboBox {
JFrame fen = new JFrame("Musique");
public static void main(String[] args) {
JPanel pan = new JPanel();
JFrame fen = new JFrame("Musique");
String[] lesElements = { "Guitare", "Basse", "Clavier", "Batterie",
"Percussions", "Flute", "Violon" }; JPanel pan = new JPanel();
JList<String> instruments = new JList<String>(lesElements); String[] lesElements = { "Guitare", "Basse", "Clavier", "Batterie",
JLabel text = new JLabel("Choississez un (des) instrument(s) : "); "Percussions", "Flute", "Violon" };
pan.add(text); JComboBox<String> instruments = new JComboBox<String>(lesElements);
pan.add(instruments); JLabel text = new JLabel("Choississez un (des) instrument(s) : ");
pan.add(text);
fen.setContentPane(pan); pan.add(instruments);
fen.setContentPane(pan);
fen.pack();
fen.pack();
fen.setVisible(true);
fen.setVisible(true);
}
} }
}

Les composants atomiques Les composants atomiques

Les glissieres : JSlider Les menus

• Les glissières permettent de proposer à l’utilisateur une interface de saisie
• Les barres de menus (JMenuBar) permettent de regrouper de nombreuses
plus intuitive qu’un champ de texte pour régler certains paramètres.
fonctions d’une manière ergonomique et hiérarchique.
• Swing propose le composant JSlider pour représenter un réglage variable.
• Les menus sont construits à partir de la classe JMenu et sont placés dans la
JMenuBar (méthode add).
import javax.swing.*; • Ces menus sont constitués d’éléments appartenant à la classe JMenuItem ou
public class TestJSlider { à l’une de ses classes filles (JRadioButtonMenuItem,
public static void main(String[] args) {
JFrame fen = new JFrame();
JCheckBoxMenuItem ).
JPanel pan = new JPanel(); • La classe JMenuItem est une classe héritant de JToggleButton.
JSlider sBlue = new JSlider(); • Les éléments de menus sont ajoutés aux menus (méthode add).
JSlider sRed = new JSlider();
JSlider sGreen = new JSlider();
pan.add(sRed); pan.add(sGreen); pan.add(sBlue);
fen.setContentPane(pan);
fen.pack();
fen.setVisible(true);
}
}

17
 23/05/2022

Les composants atomiques Les composants atomiques

Les menus Les menus

import javax.swing.*; import javax.swing.*;
public class TestJMenu { public class TestJMenu {
public static void main(String[] args) { public static void main(String[] args) {
JFrame fen = new JFrame(); JFrame fen = new JFrame();
JMenu menuFichier = new JMenu(" Fichier "); JMenu menuFichier = new JMenu(" Fichier ");
JMenuItem menuFichierNouveau = new JMenuItem(" Nouveau "); JMenuItem menuFichierNouveau = new JMenuItem(" Nouveau ");
JMenuItem menuFichierOuvrir = new JMenuItem(" Ouvrir "); JMenuItem menuFichierOuvrir = new JMenuItem(" Ouvrir ");
JMenuItem menuFichierFermer = new JMenuItem(" Fermer "); JMenuItem menuFichierFermer = new JMenuItem(" Fermer ");
JMenuItem menuFichierQuitter = new JMenuItem(" Quitter "); JMenuItem menuFichierQuitter = new JMenuItem(" Quitter ");
menuFichier.add(menuFichierNouveau); menuFichier.add(menuFichierOuvrir); menuFichier.add(menuFichierNouveau); menuFichier.add(menuFichierOuvrir);
menuFichier.add(menuFichierFermer); menuFichier.add(menuFichierFermer);
menuFichier.add(menuFichierQuitter); menuFichier.add(menuFichierQuitter);
JMenu menuEdition = new JMenu(" Edition "); JMenu menuEdition = new JMenu(" Edition ");
JMenuItem menuEditionCouper = new JMenuItem(" Couper "); JMenuItem menuEditionCouper = new JMenuItem(" Couper ");
JMenuItem menuEditionCopier = new JMenuItem(" Copier "); JMenuItem menuEditionCopier = new JMenuItem(" Copier ");
JMenuItem menuEditionColler = new JMenuItem(" Coller "); JMenuItem menuEditionColler = new JMenuItem(" Coller ");
menuEdition.add(menuEditionCouper); menuEdition.add(menuEditionCopier); menuEdition.add(menuEditionCouper); menuEdition.add(menuEditionCopier);
menuEdition.add(menuEditionColler); menuEdition.add(menuEditionColler);
JMenuBar barreMenu = new JMenuBar(); JMenuBar barreMenu = new JMenuBar();
barreMenu.add(menuFichier); barreMenu.add(menuEdition); barreMenu.add(menuFichier); barreMenu.add(menuEdition);
fen.setJMenuBar(barreMenu); fen.setJMenuBar(barreMenu);
fen.setSize(300, 200); fen.setVisible(true); fen.setSize(300, 200); fen.setVisible(true);
} }
} }

Les composants atomiques Les composants atomiques

Les dialogues de sélection de fichiers : JFileChooser Les dialogues de sélection de fichiers : JFileChooser
• Swing propose une boite de sélection de fichier(s) • Contrairement aux boites de
avec la classe JFileChooser. dialogues, un objet doit être
instancié.
• La classe propose trois méthodes pour afficher un • La méthode getSelectedFile
dialogue d’ouverture de fichier. renseigne sur le nom du fichier
sélectionné.
▫ showOpenDialog : présente une boite de dialogue
pour l’ouverture d’un fichier
import javax.swing.*;
▫ showSaveDialog : pour la sauvegarde d’un fichier. public class TestJFileChooser {
public static void main(String[] args) {
▫ showDialog : permet de spécifier des chaînes de JFrame fen = new JFrame("Test JFileChooser");
caractères pour le bouton de validation et le titre de la fen.setVisible(true);
fen.setSize(500, 500);
fenêtre afin de créer des boîtes personnalisées. JFileChooser fc = new JFileChooser();
if (fc.showOpenDialog(fen) == JFileChooser.APPROVE_OPTION){
• Les trois méthodes renvoient un entier dont la System.out.println(" Le fichier est : " + fc.getSelectedFile());
}
valeur correspond au bouton qui a été cliqué. }
}

18
 23/05/2022

Les composants atomiques Les composants atomiques

Les composants orientes texte : JTextField, JTextArea, JEditorPane Le champ de saisie JTextField
• Swing propose cinq composants pour travailler avec du texte: • JTextField est utilisé pour saisir une seule ligne de texte.
JTextField, JFormatedTextField, JPasswordField, • Construit un champ de saisie dont la largeur peut être fixée
JTextArea, JEditorPane et JTextPane. avec setColumns.
▫ descendent (directement ou non) de JTextComponent.
• JTextComponent : Implémente une architecture MVC (Model-View-
Controler). import javax.swing.*;
public class TestJTextField {
▫ Sans rentrer dans les détails, elle sépare la partie affichage des public static void main(String[] args) {
données des données elles-mêmes. JFrame fen = new JFrame("Test JTextField");
JPanel pan = new JPanel();
• Pour la classe JTextComponent cela se manifeste sous la forme d’une JLabel lNom = new JLabel("Entrez votre nom : ");
JTextField tfNom = new JTextField();
classe membre interne de type Document qui contient les données tfNom.setColumns(15);
texte. pan.add(lNom);
pan.add(tfNom);
fen.setContentPane(pan);
fen.setSize(400, 100);
fen.setVisible(true);
}
}

Les composants atomiques Les composants atomiques

La zone de texte JTextArea Visualisateur de documents formates JEditorPane

• JTextArea est utilisé pour afficher un texte sur plusieurs • JEditorPane permet de gérer des affichages complexes ou/et des
lignes. documents plus riches (formats RTF et HTML).
• Le texte est affiché en bloc, avec une police unique (mais
modifiable). import java.io.IOException;
import javax.swing.*;
import javax.swing.*; public class TestJEditorPane {
public class TestJTextArea { public static void main(String[] args) {
public static void main(String[] args) { JFrame fen = new JFrame();
JFrame fen = new JFrame(); JEditorPane epNotes = new JEditorPane();
JPanel pan = new JPanel(); epNotes.setEditable(false);
JTextArea taNotes = new JTextArea(); try {
taNotes.setText("Trois anneaux\npourles ombres...\n"); epNotes.setPage(" http://www.google.com");
taNotes.setEditable(false); fen.setContentPane(epNotes);
pan.add(taNotes); fen.setSize(800, 500);
fen.setContentPane(pan); fen.setVisible(true);
fen.setSize(400, 100); } catch (IOException e) {
fen.setVisible(true); System.out.println(e.getMessage());
} }
} }
}

19
 23/05/2022

Les composants atomiques Les composants atomiques

Le composant JTable Le composant JTable

• JTable permettant d'afficher un tableau formé d'un certain nombre import java.awt.BorderLayout;
import javax.swing.*;
de lignes et de colonnes.
• JTable a également une ligne d'en-tête présentant un titre pour public class TableBasique extends JFrame {
public TableBasique() {
chaque colonne. setTitle("JTable basique dans un JPanel");
▫ On peut voir les données comme un tableau à deux dimensions setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Object[][] donnees = {
dans lequel chaque valeur correspond à la valeur d'une cellule du {"Cysboy", "28 ans", "1.80 m"},
tableau. {"BZHHydde", "28 ans", "1.80 m"},
{"IamBow", "24 ans", "1.90 m"},
▫ Quant aux en-têtes, on peut les voir comme un tableau de chaînes {"FunMan", "32 ans", "1.85 m"}
de caractères. } ;
String[] titreColonnes = {"Pseudo", "Age", "Taille"};
• Le JTable utilise différents concepts de Swing : JTable tableau = new JTable(donnees, titreColonnes);
▫ TableModel : Un modèle pour stocker les données.
getContentPane().add(tableau.getTableHeader(), BorderLayout.NORTH);
▫ TableCellRenderer : Un renderer pour le rendu des cellules. getContentPane().add(tableau, BorderLayout.CENTER);
pack();
▫ TableCellEditor : Un éditeur pour l'édition du contenu d'une }
cellule. public static void main(String[] args) {
new TableBasique().setVisible(true);
}
}

Les composants atomiques Les composants atomiques

Le positionnement des composants Le positionnement absolu

• Java dispose des composants graphiques en fonction de règles
simples qui permettront un aspect visuel quasiment identique • Approche peu recommandée.
d’un système à l’autre. • On utilise setLayout(null) pour désactiver
• Ces règles de placement sont définies à l’aide d’objets :
le gestionnaire par défaut du conteneur.
▫ Les gestionnaires de placement.
• Les composants sont ensuite placés en utilisant
Conteneur Gestionnaire par défaut
les coordonnées absolues à l’aide de la méthode
JPanel, JApplet FlowLayout
setLocation.
JFrame, JWindow BorderLayout
• La taille du composant peut être imposée en
• Les gestionnaires de placement implémentent l’interface utilisant la méthode setSize.
LayoutManager et utilisent les méthodes
getPreferedSize / getMinimumSize, pour connaître la
taille préférée/ minimale des composants.

20
 23/05/2022

Exemple : Position absolue

public class TestPositionAbsolu {
public static void main(String[] args) {
Exemple : Position absolue
JFrame fen = new JFrame("Test Position absolu");
fen.setLayout(null);
JLabel loginLabel = new JLabel("Login");
JLabel passwordLabel = new JLabel("Mot de passe");

JTextField loginText = new JTextField(15);

JPasswordField passwordText = new JPasswordField(15);

JButton validerButton = new JButton("Valider");

loginLabel.setLocation(70, 10);
loginLabel.setSize(150, 20);
// loginLabel.setBounds(70, 10, 150, 20);

loginText.setBounds(150, 10, 150, 20);

passwordLabel.setBounds(70, 40, 150, 20);
passwordText.setBounds(150, 40, 150, 20);
validerButton.setBounds(70, 70, 100, 20);

fen.add(loginLabel); fen.add(loginText);
fen.add(passwordLabel); fen.add(passwordText);
fen.add(validerButton);
fen.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
fen.setSize(400, 150); fen.setVisible(true);
}
}

LayoutManager LayoutManager
Plusieurs types de « LayoutManager » sont disponibles:
• Lorsque vous ajoutez un composant à un
composant conteneur, ce dernier doit calculer la –BorderLayout : initialisé pour tous les composants de haut
position et la taille du nouveau composant. niveau
• Pour cela, le composant conteneur utilise un –BoxLayout : simple ligne ou colonne
gestionnaire de disposition appelé « –CardLayout : zone qui contient des composants pouvant
changer en cours de fonctionnement
LayoutManager » –FlowLayout : par défaut pour tous les JPanel – une ligne
• Un « LayoutManager » implante différentes règles avec passage à la ligne par manque de place
pour placer les composants les uns par rapport aux –GridLayout : utilisation d’une grille de cellules ayant la
même taille
autres. –GridBagLayout : utilisation d’une grille de cellules qui
• Ainsi, la position et la taille des composants dans peuvent être de tailles différentes, les composants peuvent en
une interface graphique n'est pas décidée par les outre être sur plusieurs cellules
–SpringLayout : layout dynamique pour le
composants, mais par un « LayoutManager » redimensionnement

21
 23/05/2022

Le gestionnaire FlowLayout
• FlowLayout est le plus élémentaire.
Exemple : Test Position absolue
• Dispose les différents composants de gauche à import java.awt.*;
droite et de haut en bas (sauf configuration import javax.swing.*;
contraire du conteneur). public class TestFlowLayout extends JPanel {
private static final long serialVersionUID = 1L;
▫ Remplit une ligne de composants puis passe à la public TestFlowLayout() {
suivante comme le ferrait un éditeur de texte. FlowLayout fl = new FlowLayout();
this.setLayout(fl);
▫ Le placement peut suivre plusieurs justifications, this.add(new JButton("Un"));
notamment à gauche, au centre et à droite. this.add(new JButton("Deux"));
this.add(new JButton("Trois"));
▫ Une version surchargée du constructeur permet de this.add(new JButton("Quatre"));
choisir cette justification (bien qu’elle puisse aussi this.add(new JButton("Cinq"));
être modifiée en utilisant la méthode }
this.add(new JButton("Six"));

setAlignement). public static void main(String[] args) {

▫ Les justifications sont définies à l’aide de variables JFrame fen = new JFrame("Test Position absolu");
fen.setContentPane(new TestFlowLayout());
statiques FlowLayout.LEFT, fen.setSize(400, 100);
FlowLayout.CENTER et FlowLayout.RIGHT. }
fen.setVisible(true);

Le gestionnaire GridLayout Exemple : GridLayout

• Le gestionnaire GridLayout propose de placer import java.awt.*;
import javax.swing.*;

les composants sur une grille régulièrement public class TestGridLayout extends JPanel {
public TestGridLayout() {

espacée. this.setLayout(new GridLayout(3, 0));

this.add(new JButton(" Un "));
this.add(new JButton(" Deux "));
• Généralement les composants sont disposés de this.add(new JButton(" Trois "));
this.add(new JButton(" Quatre "));
gauche à droite puis de haut en bas. this.add(new JButton(" Cinq "));
this.add(new JButton(" Six "));
➔Cette disposition peut être modifiée en utilisant this.add(new JButton(" Sept "));
}
la méthode ComponentOrientation du public static void main(String[] args) {

conteneur. JFrame fen = new JFrame("Test Position absolu");

fen.setContentPane(new TestGridLayout());
fen.setSize(400, 100);
• Le nombre de lignes et de colonnes sont fixés à fen.setVisible(true);
}
l’aide des méthodes setRows et setColumns. }

22
 23/05/2022

Le gestionnaire BorderLayout Exemple : BorderLayout

• Le gestionnaire BorderLayout définit cinq zones import java.awt.*;
import javax.swing.*;
dans le conteneur : public class TestBorderLayout extends JPanel {
▫ une zone centrale (CENTER) et quatre zones périphériques public TestBorderLayout() {
this.setLayout(new BorderLayout());
(EAST, WEST, NORTH, SOUTH). this.add(new JButton(" North "), BorderLayout.NORTH);
• Les composants placés dans les zones NORTH et SOUTH this.add(new JButton(" South "), BorderLayout.SOUTH);
this.add(new JButton(" East "), BorderLayout.EAST);
sont dimensionnés à la hauteur qu’ils souhaitent puis this.add(new JButton(" West "), BorderLayout.WEST);
this.add(new JButton(" Center "), BorderLayout.CENTER);
étendus en largeur. }
• A l’inverse les composant des zones EAST et WEST sont public static void main(String[] args) {
JFrame fen = new JFrame("Test BorderLayout");
placés à leurs largeurs voulues et étendus en hauteur. fen.setContentPane(new TestBorderLayout());
fen.setSize(400, 200);
• Le composant placé dans la zone CENTER est utilisé pour fen.setVisible(true);
combler le vide. }
}

• Pour ajouter un composant, on une utilise une version

surchargée de la méthode add, add(component,
constraints) où component est un composant et
constraints un objet représentant la position voulue.

Le gestionnaire GridBagLayout Exemple : GridBagLayout

• GridBagLayout est le gestionnaire le plus complet et le public class TestGridBagLayout extends JPanel {
public TestGridBagLayout() {
plus souple. this.setLayout(new GridBagLayout());
GridBagConstraints contraintes = new GridBagConstraints();
• Comme le GridLayout, il place les composants sur une contraintes.gridx = 0;
contraintes.gridy = 0;
grille tout en autorisant les composants à prendre des this.add(new JButton(" Un "), contraintes);
libertés. contraintes.gridx = 1;
contraintes.gridy = 0;
▫ les composants peuvent occuper plusieurs cellules, se répartir this.add(new JButton(" Deux "), contraintes);
contraintes.gridx = 0;
l’espace restant,… contraintes.gridy = 1;

• Le constructeur de GridBagLayout n’admet aucun

this.add(new JButton(" Trois "), contraintes);
contraintes.gridx = 1;
paramètre, ils sont passés par la méthode add via un objet contraintes.gridy = 1;
this.add(new JButton(" Quatre "), contraintes);
de type GridBagConstraints. contraintes.gridx = 2;
contraintes.gridy = 2;
• Le gestionnaire GridBagLayout utilise plus d’une dizaine }
this.add(new JButton(" Cinq "), contraintes);

de paramètres, pour éviter une surcharge trop lourde de la public static void main(String[] args) {
méthode add, on passe un objet de la classe JFrame fen = new JFrame("Test GridBagLayout");
fen.setContentPane(new TestGridBagLayout());
GridBagConstraints qui représente tout ou partie de ces fen.setSize(300, 200);
fen.setVisible(true);
paramètres. }
}

23
 23/05/2022

Un exemple complet Un exemple complet

• Voici un exemple complet utilisant les composants de import
import
java.awt.*;
javax.swing.*;
base de Swing import javax.swing.border.TitledBorder;
public class BigExample {

...

private JPanel createMainPanel(String... list) {

return createBoxPanel(createTextFieldPanel(), createTextAreaPanel(),
createComboBoxPanel(list), createListPanel(list),
createCheckBoxes(createTitledPanel("boutons à cocher"), list),
createRadioButton(createTitledPanel("boutons radio"), list));
}
public static void main(String[] args) {
JFrame frame = new JFrame("Gros exemple");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
BigExample example = new BigExample();
JPanel panel = example.createMainPanel("SWT", "Swing", "IlogViews",
"AWT", "Motif");
frame.setContentPane(panel);
frame.setSize(400, 400);
frame.setVisible(true);
}
}

Etiquette, champs de texte, zone de

Bordure et Assemblage de l'interface texte
• JLabel, JTextField et JTextArea prennent un texte lors de la construction
• N'importe quel composant swing peut avoir
une bordure
public class BigExample {
public class BigExample {
private JPanel createForm(String text, JComponent c) {
... JPanel panel = new JPanel(new GridBagLayout());
GridBagConstraints constraints = new GridBagConstraints();
private JPanel createBoxPanel(JPanel... panels) { constraints.weightx = 1.0;
JPanel panel = new JPanel(null); panel.add(new JLabel(text), constraints);
constraints.weightx = 5.0;
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
constraints.fill = GridBagConstraints.HORIZONTAL;
for (JPanel p : panels) constraints.gridwidth = GridBagConstraints.REMAINDER;
panel.add(p); panel.add(c, constraints);
return panel; return panel;
} }
public JPanel createTextFieldPanel() {
JTextField textField = new JTextField();
private JPanel createTitledPanel(String title) {
return createForm("TextField", textField);
JPanel panel = new JPanel(); }
TitledBorder border = new TitledBorder(title); public JPanel createTextAreaPanel() {
panel.setBorder(border); JTextArea textArea = new JTextArea("sur plusieurs\nlignes\n");
return panel; return createForm("TextArea", textArea);
} }
...
}
...

24
 23/05/2022

Boutons à cocher
Liste et Liste déroulante
• JCheckBox correspond à une case à cocher
• JComboBox et JList peuvent prendre un tableau • JRadioButton correspond à un bouton radio
(String[]) à la construction public class BigExample {
...
public class BigExample { private JPanel createCheckBoxes(JPanel panel, String... list) {
... for (String s : list) {
public JPanel createComboBoxPanel(String... list) { JCheckBox checkBox = new JCheckBox(s);
JComboBox<String> comboBox = new JComboBox<String>(list); panel.add(checkBox);
return createForm("ComboBox", comboBox); }
} return panel;
}
public JPanel createListPanel(String... array) { ...
JList<String> list = new JList<String>(array); }
list.setVisibleRowCount(4);
JScrollPane scrollPane = new JScrollPane(list);
return createForm("Liste", scrollPane);
}
... • JCheckBox, JRadioButton comme JButton
}
héritent d'AbstractButton

Boutons radio et groupe de boutons

• Pour avoir un seul bouton sélectionné à la Principe des évènements
fois, le bouton doit faire partie d'un • Java propose des mécanismes de communication
ButtonGroup entre les objets basés sur des événements.
public class BigExample {
...
• Un évènement est émis par un objet (source) et
private JPanel createRadioButton(JPanel panel, String... list) { reçu par un ou plusieurs objets (auditeurs).
ButtonGroup group = new ButtonGroup();
for (String s : list) { ➔On dit que la source notifie un événement aux
JRadioButton radioButton = new JRadioButton(s);
panel.add(radioButton);
auditeurs.
}
group.add(radioButton);
• Pour pouvoir recevoir un (ou des) événement(s), les
return panel; auditeurs doivent s’enregistrer auprès de la (des)
source(s).
}
...
}

• ButtonGroup est un composant logique pas

➔Principe du patron de conception
Observateur
graphique

25
 23/05/2022

Les évènements
• Les événements sont des héritiers de la classe Source et auditeurs
EventObject.
▫ EventObject ne propose qu’une méthode getSource • La source : doit être capable de créer des
qui renvoie l’objet qui a crée cet événement.
▫ Le constructeur de EventObject admet l’objet qui l’a
évènements et de les transmettre aux auditeurs.
crée comme seul paramètre. • Les auditeurs : doivent pouvoir s’enregistrer
▫ Il est évidement possible de surcharger le constructeur auprès de la source mais peuvent aussi se libérer
lors de l’héritage en fonction des besoins.
• Par convention, les noms des objets sont de la forme de cette relation et doivent implémenter une
XXXEvent. interface qui dérive de EventListener.
• Le constructeur de la classe EventObject nécessite la ▫ En pratique, cette interface a un nom de la forme
source comme paramètre. XXXListener et doit comprendre une méthode
qui admet comme argument un élément de type
XXXEvent.

Gestion des événements dans Swing Gestion des événements dans Swing
• Tous les composants de Swing (et de AWT) créent • Exemple : le composant JAbstractButton (et
des évènements en fonction des actions de donc tous ses descendants) possède une méthode
l’utilisateur. addActionListener utilisée pour enregistrer
une classe implémentant l’interface
• Les évènements sont des descendants de ActionListener.
EventObject, noté XXXEvent. • L’interface ActionListener n’a qu’une méthode
• Les composants proposent des méthodes du type actionPerformed(ActionEvent e) qui doit
AddXXXListener pour enregistrer un auditeur. être implémentée pour gérer l’évènement
(l’évènement est disponible via le paramètre e).
• L’auditeur doit implémenter l’interface • La classe ActionEvent propose plusieurs
correspondante qui est de la forme XXXListener. méthodes utiles comme getSource pour
identifier la source de l’évènement.

26
 23/05/2022

Les différents évènements

• Swing dispose de deux types d’évènements : Evènements de base
▫ Evènements de base : communs à tous les
descendants de Component (et donc de Evènements Description
JComponent), couvrent les évènements bas- ComponentEvent Un composant a bougé, changé de taille, changé de
visibilité.
niveau comme les mouvements de la souris, la ContainerEvent Un composant a été ajouté/enlevé du conteneur.
modification des composants ou l’utilisation du FocusEvent Le composant a gagné/perdu le focus.
clavier. KeyEvent Une touche a été appuyée/relâchée.
▫ Evènements sémantiques : représentent MouseEvent La souris a bougée ou l’un des boutons a changé d’état.
des actions de haut-niveau de l’utilisateur MouseWheelEvent La molette de souris a été tournée.
comme la sélection d’un menu, la modification WindowEvent La fenêtre a été réduite/redimensionnée/agrandie.
du curseur dans les composants textuels, ...

Gestion des évènements par

Evènements sémantiques
la classe graphique
Evènements Description • L’approche la plus simple de mise en œuvre.
ActionEvent De nombreux éléments génèrent cet événement : un import java.awt.event.*;
JButton lors d’un clic de souris, un élément de menu import javax.swing.*;
(JXXXMenuItem) est sélectionné, la touche Entrée a public class TestEvent1 extends JPanel implements ActionListener {
JButton leBouton;
pressée dans JTextField,. . . JTextField leTextField;
ChangeEvent Un changement d’état a eu lieu dans un composant : un public TestEvent1() {
leBouton.addActionListener(this);
élément radio (bouton ou menu), une case à cocher ,,,,,
(bouton ou menu), un bouton ou un élément de menu a
changé d’état, une glissière a bougée, changement d’onglet }
public void actionPerformed(ActionEvent e) { }
dans un JTabbedPane,. . .
CaretEvent Modification de la position du curseur dans un élément }
JTextComponent ou un de ses descendants.
ItemEvent Un nouvel élément a été sélectionné dans une
JComboBox.
ListSelectionEven Un nouvel élément a été sélectionné dans une JList. • Cette méthode est très simple lorsque le nombre
t d’évènements à gérer est faible.
... ...

27
 23/05/2022

Gestion des évènements par Gestion des évènements par

la classe graphique la classe graphique
• L’approche la plus simple de mise en œuvre. • Si deux (ou plus) composants émettent le même
import java.awt.event.*;
import javax.swing.*; évènement, il faut identifier la source de
public class TestEvent1 extends JPanel implements ActionListener, KeyListener {
JButton leBouton; l’évènement dans la procédure concernée à l’aide
JTextField leTextField;
public TestEvent1() { de getSource.
leBouton.addActionListener(this); import java.awt.event.*;
leTextField.addKeyListener(this); import javax.swing.*;
} public class TestDeuxBouton extends JPanel implements ActionListener {
public void actionPerformed(ActionEvent e) { } JButton leBouton1, leBouton2;
public TestDeuxBouton() {
public void keyTyped(KeyEvent e) { } leBouton1.addActionListener(this);
leBouton2.addActionListener(this);
public void keyPressed(KeyEvent e) { } }
public void actionPerformed(ActionEvent e) {
public void keyReleased(KeyEvent e) { } if (e.getSource() == leBouton1) {
} // La source est leBouton1

• Cette méthode est très simple lorsque le nombre }

if (e.getSource() == leBouton2) {
d’évènements à gérer est faible. }
// La source est leBouton2

}
}

Gestion des évènements par Gestion des évènements par

des classes dédiées des classes dédiées
• Consiste à construire une classe par auditeur
• Les deux auditeurs sont instanciés dans les
d’évènement.
public class ListenerBouton1 implements ActionListener{
public void actionPerformed(ActionEvent e) {
// Partie utile méthodes d’enregistrement car aucune
référence n’est nécessaire.
}
}

public class ListenerBouton2 implements ActionListener{

public void actionPerformed(ActionEvent e) { • Les classes auditeurs n’ont pas directement
}
// Partie utile
accès aux variables membres de la classe
}
visuelle.
public class TestClassesExternes extends JPanel {
JButton leBouton1, leBouton2;
public TestClassesExternes() {
• Ils est donc nécessaire de créer des références
leBouton1 = new JButton(" Bouton 1");
leBouton2 = new JButton(" Bouton 2");
entre ces deux éléments.
leBouton1.addActionListener(new ListenerBouton1());
leBouton2.addActionListener(new ListenerBouton2());
}
}

28
 23/05/2022

Gestion des évènements par Gestion des évènements par

des classes membres internes des classes membres internes
• Le problème évoqué avant peut être résolu en import java.awt.event.*;
import javax.swing.*;
utilisant des classes membres internes. public class TestClassesMembres extends JPanel {
JButton leBouton1, leBouton2;

• Les classes membres peuvent accéder facilement

public TestClassesMembres() {
leBouton1 = new JButton("Bouton 1");
leBouton2 = new JButton("Bouton 2");
aux éléments de la classe graphique. leBouton1.addActionListener(new ListenerBouton1());
leBouton2.addActionListener(new ListenerBouton2());
• Cette méthode conduit à créer une classe }
private class ListenerBouton1 implements ActionListener {

membre interne par composant et par public void actionPerformed(ActionEvent e) {

// Partie utile

évènement. }
}

private class ListenerBouton2 implements ActionListener {

public void actionPerformed(ActionEvent e) {
// Partie utile
}
}
}

Gestion des évènements par des

Gestion des évènements par des classes membres internes anonymes
public class TestClassesAnonymes extends JPanel {

classes membres internes anonymes JButton leBouton;

JTextField leTextField;
public TestClassesAnonymes() {
• Dans le cas des auditeurs, les classes sont leBouton = new JButton(" Bouton 1");
leTextField = new JTextField();
simplement instanciées pour être ensuite utilisée leBouton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

comme paramètre de la fonction }

// Partie utile

addXXXListener. });
leTextField.addKeyListener(new KeyListener() {
public void keyTyped(KeyEvent e) {
• Les instanciations inutiles sont supprimées et }
// Partie utile

chaque auditeur est rattaché à un seul objet. public void keyPressed(KeyEvent e) {

// Partie utile

• Cette approche permet de facilement modifier le }

public void keyReleased(KeyEvent e) {

code, si un on ajoute (ou on enlève) un

// Partie utile
}
});
composant ou/et un évènement. }
}

29