Chapitre 7: Java

Swing & les

interfaces Homme-
Machine (IHM)

1
 Introduction
Bibliothèque JFC (Java Foundation Classes)
❖AWT (Abstract Windowing Toolkit)
❑Une bibliothèque graphique pour Java, faisant partie
de JFC,
❑Introduite dès les premières versions de Java,
❑Un rôle important dans le succès de Java composants
lourds.
❖Swing
❑Composants légers,
❑Offre la possibilité de créer des interfaces graphiques
identiques quel que soit le système d'exploitation
❑Fournit les classes pour la représentation des
différents éléments d’interfaces graphiques: fenêtres,
boutons, menus, etc., et la gestion des événements.
2
 Possibilités de java.awt
❑Avec java.awt, on peut par exemple:
❖Tracer différentes formes (rectangles, ovales,…)
❖Définir des polices des caractères, des couleurs…
❖Créer des composants simples tels que boutons, cases à
cocher, libellés, …
❖Créer des composants plus complexes tels que boites
de dialogue, menu déroulants, …
❖Gérer des événements des utilisateurs (clique sur un
bouton, …)

3
 Principales classes de java.awt
Classe Graphics
La classe java.awt.Graphics comporte un nombre important
de méthodes permettant de tracer des formes géométriques
vides ou pleines. Parmi les méthodes, on trouve:
❖drawLine(int x1,int y1,int x2,int y2)
❖drawString(String texte,int x,int y)
❖drawRectangle(int x,int y,int larg,int haut)
❖fillRectangle(int x,int y,int larg,int haut)
❖drawOval(int x,int y, int larg,int haut)
❖fillOval(int x,int y, int larg,int haut)
❖drawPolygon(xpoints,ypoints,points)
❖fillPolygon(xpoints,ypoints,points)

4
 Principales classes de java.awt
Classe Color
❑La classe java.awt.Color permet la gestion de couleurs en java.
Les couleurs peuvent être spécifiées de plusieurs manières:
❖Noms standards prédéfinis (black, blue, red, orange, green, …):
Color.nom_couleur
❖Trois nombres entre 0 et 255 (trois couleurs RGB):
Color macouleur=new Color(150,200,250)
❖Trois nombres floats entre 0.0 et 1.0:
Color macouleur=new Color(1.0f,0.5f,0.7f)
❑Remarques:
❖La méthode setColor() de java.awt.Graphics : Afficher un texte
ou un graphique dans une couleur spécifique.
❖La méthode setBackground() : Définir la couleur de l’arrière
plan

5
 Principales classes de java.awt
Classe Font
❑L’affichage d’un caractère est défini par trois éléments:
❖Nom de la police: Times Roman, Courier, Helvetica, …
❖Style de la police: gras, italique ou normal
❖Taille de la police en points
❑Pour afficher un texte dans une police définie, avec un style
défini et une taille précise, on doit déclarer un objet Font
contenant ces informations. Le constructeur de la classe
Font est:
Font(String nom,int style,int taille)
❑Le style peut être l’une des constantes: Font.PLAIN,
Font.BOLD, Font.ITALIC
❑Remarque: La méthode getFontList() de java.awt.Toolkit
affiche la liste des polices

6
 Principales classes de java.awt
Example 1
import javax.swing.*; import java.awt.*;
class Forme extends JPanel {
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.BLUE);
Font ft = new Font("Calibri", Font.BOLD, 25);
g.setFont(ft); g.drawString("Rectangle", 30, 50);
g.setColor(Color.RED);
g.fillRect(70, 120, 170, 170);
}
}
7
 Principales classes de java.awt
public class Test_Forme {
public static void main(String[] args) {
JFrame frame = new JFrame("Tracer les formes");
frame.setSize(400, 400);
Forme formePanel = new Forme();
frame.add(formePanel);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CL
OSE);
frame.setVisible(true);
}
}
8
Principales classes de java.awt

9
 Principales classes de java.awt
Example 2
import javax.swing.*; import java.awt.*;
class Forme extends JPanel {
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.BLUE);
Font ft = new Font("Calibri", Font.BOLD, 25);
g.setFont(ft); g.drawString("Hexagone", 30, 50);
g.drawString("Carré", 230, 50); g.setColor(Color.RED);
drawHexagon(g, 70, 120, 60); g.setColor(Color.GREEN);
g.fillRect(230, 120, 100, 100);
}
10
 Principales classes de java.awt
private void drawHexagon(Graphics g, int x, int y, int
radius) {
int[] xPoints = new int[6];
int[] yPoints = new int[6];
for (int i = 0; i < 6; i++) {
xPoints[i] = x + (int) (radius * Math.cos(i * 2 *
Math.PI / 6));
yPoints[i] = y + (int) (radius * Math.sin(i * 2 *
Math.PI / 6));
}
g.fillPolygon(xPoints, yPoints, 6);
}
}
11
 Principales classes de java.awt
public class Test_Forme {
public static void main(String[] args) {
JFrame frame = new JFrame("Tracer les formes");
frame.setSize(400, 400);
Forme formePanel = new Forme();
frame.add(formePanel);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE
);
frame.setVisible(true);
}
}

12
Principales classes de java.awt

13
 Structure générale de Swing
❑Il existe deux principaux types d’objets sous Swing:
❖Les conteneurs: comme leur nom l'indique, à contenir
les objets du second type nommés composants, par
exemple les fenêtres ;
❖Les composants: qui ne peuvent pas contenir d’autres,
comme par exemple les boutons.

14
 Structure générale de Swing
Une application est composée :
❑Les conteneurs de premier niveau (Top-Level Containers):
❖Ils constituent toujours les objets de base d'une interface Swing
❖les plus utilisés sont: les cadres (JFrame) , les dialogues (JDialog)
et les applets (JApplet), il existe également les JWindow mais ils
ne sont pas utilisés.
❑Les conteneurs intermédiaires : sont destinés à contenir d’autres
composant :
❖les panneaux (Jpanel),
❖les panneaux défilants (JScrollPane),
❖les panneaux divisables (JSplitPane), …
15
 Structure générale de Swing
Une application est composée :
❑Les composants atomiques : Ce sont les briques qui
vont servir à la construction de l'interface:
❑un bouton (Jbutton),
❑barre de progression (JProgressBar)
❑un label (JLabel), ..

16
Composants Swing

17
Interacteurs
 Boutons

JButton JCheckbox : JRadioButton :

choix choix exclusif :
idépendants cf. ButtonGroup
 Texte

JTextField

JPasswordField

JTextArea :
texte simple
multilignes
Ascenseurs : JEditorPane : texte
JScrollPane avec styles compatible
HTML et RTF
 Conteneurs

JPanel: conteneur
... générique

JScrollPane: JSplitPane:
avec ascenseurs intégrés avec « diviseur » intégré
 Conteneurs
JToolBar: barre
d’outils (sous la
barre de menus)

JTabbedPane
: onglets JTree

JTable
 Fenêtres

JFrame : fenêtre principale de l’application

JDialog : fenêtre secondaire
❑ dépendante de la JFrame (en théorie pas
d’iconification séparée, toujours au dessus)
JDialog modal : bloque l’interaction => l’utilisateur de
répondre
 Fenêtres

Créent des paneaux intermédiaires

❑ ContentPane : conteneur où on
ajoute les composants
graphiques
❑ GlassPane : conteneur
transparent superposé (pour
usages avancés)
 Boîtes de dialogue prédéfinies

JFileChooser JColorChooser

Peuvent être créés :

❑ comme boîtes de
dialogue
JOptionPane
❑ ou comme conteneurs
(multiples variantes)
Menus

raccourci
clavier
(accelerator)
mnémonique
Arbre d’instanciation
 Structure générale de Swing
JFrame fenetre= new JFrame("fenetre JFrame");
Container conteneur1= fenetre.getContentPane();
JPanel PanneauBleu = new JPanel();
PanneauBleu.setBackground( new Color (0,0,200));
JTextField composant1= new JTextField("Champs de
texte");
JCheckBox composant2= new JCheckBox("Cases à
cocher");
JButton composant3= new JButton("Création de
bouton ");
28
 Structure générale de Swing
GridLayout layoutPanneauBleu = new GridLayout(2,1);
layoutPanneauBleu. setVgap(3);
PanneauBleu.setLayout(PanneauBleu);
conteneur1.add(PanneauBleu);
conteneur1.add(composant3);
PanneauBleu.add(composant1);
PanneauBleu.add(composant2);

29
 Le composant JComponent
Tous les objets (conteneurs et composants) héritent de la
même classe : javax.swing.Jcomponent.
Exemples :

Montrer et cacher un
void setVisible ( boolean b)
composant
Activer et désactiver un
void setEnabled ( boolean b)
composant
Connaître l’état (activé ou
boolean isEnabled ()
non) d’un composant

30
 Le composant JComponent

void setBackground ( Color Modifier la couleur de

c) fond d’un composant
Modifier la couleur du
void setForeground(Color c) premier plan d’un
composant
void setSize ( int largeur , int Modifier la taille d’un
hauteur ) composant
void setBounds ( int x, int y, Modifier la position et la
int largeur , int hauteur ) taille d’un composant

31
 Les conteneurs de premier niveau
❑Ce groupe comprend: les cadres (JFrame), les
dialogues (JDialog), les applets (JApplet) et la fenêtre
la plus basique (Jwindow)
❑Ils constituent toujours les objets de base d'une
interface Swing.
❑Un conteneur de premier niveau peut contenir des
objets d'une des sous-classes de Jcomponent, mais
n'est pas destiné à être contenu dans un autre
conteneur de premier niveau.

32
 Les conteneurs de premier niveau
❑Exemple 1: Jframe
❑On crée une nouvelle instance de notre Jframe
Jframe fenetre= new JFrame ("Example de fenêtre");
❑La fenêtre doit se fermer quand on clique sur la croix
rouge
fenetre.setDefaultCloseOperation(JFrame.DISPOSE_O
N_CLOSE);
❑On ajoute le texte « Bonjour!" dans la fenêtre
fenetre.getContentPane().add(new JLabel(" Bonjour
!"));
33
 Les conteneurs de premier niveau
getContentPane() :
❑Dans Swing, chaque JFrame possède un Content
Pane (ou panneau de contenu), qui est la zone
principale de la fenêtre où l’on peut ajouter des
composants comme des boutons, étiquettes, champs de
texte, etc.
❑La méthode getContentPane() récupère ce Content
Pane, permettant ainsi d’interagir avec lui (par
exemple, pour lui ajouter des composants ou modifier
ses propriétés).

34
 Les conteneurs de premier niveau
Exemple 2 : Jdialog
❑On crée une nouvelle instance de notre JDialog
JDialog fenetre = new JDialog();
❑On lui donne un titre
fenetre.setTitle(”Première fenêtre Swing”);
❑On dit à l'application de se fermer lors du clic sur la
croix
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

35
 Les conteneurs de premier niveau
Exemple 3: Jwindow
❑On crée une nouvelle instance de notre JWindow
JWindow fenetre = new JWindow();
❑On lui donne une taille pour qu'on puisse la voir
fenetre.setSize(200, 300);
❑On la rend visible
fenetre.setVisible(true);

36
 Création d’une JFrame
import javax.swing.*;
class Fenetre {
public static void main ( String args []){
JFrame fenetre = new JFrame (" Titre de la
Fenetre ");
fenetre.setSize(300, 300);
fenetre.setVisible ( true );
}
}

37
 Fermeture d’une JFrame
❑La fermeture d’une fenêtre de type JFrame ne met pas fin
au programme, mais rend simplement la fenêtre invisible :
window.setVisible(false); //On la rend invisible
❑Il est possible de préciser comment JFrame réagit à sa
fermeture grâce à la méthode
setDefaultCloseOperation():
❖WindowConstants.DISPOSE_ON_CLOSE : détruit la
fenêtre
❖WindowConstants.DO_NOTHING_ON_CLOSE : rend le
bouton de fermeture inactif
❖WindowConstants.HIDE_ON_CLOSE : cache la fenêtre
38
 Fermeture d’une JFrame
Exemple: Création d’une fenêtre « ma fenetre » avec le
bouton de fermeture inactif.
import javax.swing.*;
public class TestJFrame3 {
public static void main(String argv[]) {
JFrame fenetre = new JFrame("ma fenetre");
fenetre.setSize(300,200);
fenetre.setDefaultCloseOperation(WindowConstant
s.DO_NOTHING_ON_CLOSE);
fenetre.setVisible(true);
}
}
39
 Les classe toolkit
❑Les classes du toolkit de AWT (Abstract Windows Toolkit)
permettent d'écrire des interfaces graphiques
indépendantes du système d'exploitation sur lesquels elles
vont fonctionner.
❑Cette librairie utilise le système graphique de la plate-
forme d'exécution (Windows, MacOS, Window-X) pour
afficher les objets graphiques.
❑Le toolkit contient des classes décrivant les composants
graphiques, les polices, les couleurs et les images.
❑On obtient une instance de Toolkit par la méthode de
classe de Toolkit :
public static Toolkit.getDefaultToolkit()
40
 Les classe toolkit
❑Exemple: Création d’une fenêtre centrée dans l’écran de l’ordinateur.
import javax.swing.*;
import java.awt.*;
public class TestJFrame5 {
public static void main(String args[]) {
JFrame fenetre = new JFrame("ma fenetre");
fenetre.setSize(300,200);
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
fenetre.setLocation(dim.width/2 - fenetre.getWidth()/2,
dim.height/2 - fenetre.getHeight()/2);
fenetre.setVisible(true);
}
}
41
 Création d’une JDialog
❑La classe JDialog permet de créer des boîtes de dialogue, qui
permettent des interaction avec l'utilisateur de l'application.
❑Un dialogue peut être :
❖modal : lorsqu’il est actif toute interaction avec les autres
fenêtres sont bloquées. Les dialogues JOptionPane sont modaux
❖non modal : ne bloque pas les interactions avec les autres
fenêtres : pour créer un dialogue non modal, on est obligé de
passer par la classe JDialog.
❑Java propose un certain nombre de boîtes de dialogue standard
obtenues à l’aide de méthodes de classe de la classe JOptionPane :
Boîtes de message, Boîtes de confirmation Boîtes de saisie, Boîtes
d’options.
❑La classe JDialog permet de construire des boîtes de dialogue
personnalisées.
42
 Création d’une JDialog
Quelques constructeurs de Jdialog

JDialog (Dialog owner) Construit une boîte de dialogue

dépendant de owner, non modale
JDialog (Dialog owner, Construit une boîte de dialogue
String titre) dépendant de owner, avec un
titre, et non modale
JDialog (Dialog owner, Construit une boîte de dialogue
String titre , Boolean modal) dépendant de owner, avec un
titre, et une modalité
JDialog (Frame owner) Construit une boîte de dialogue
dépendant de owner et non modale

43
 Création d’une JDialog
Quelques constructeurs de Jdialog

JDialog (Frame owner, Construit une boîte de dialogue

boolean modal) dépendant de owner, avec une
modalité
JDialog (Frame owner, Construit une boîte de dialogue
String titre) dépendant de owner, avec un
titre, et non modale
JDialog (Frame owner, Construit une boîte de dialogue
String titre, boolean modal) dépendant de owner, avec un
titre, et une modalité

44
 Création d’une JDialog
Quelques méthodes de JDialog

void dispose() Détruit la boîte de dialogue

String getTitle() Retourne le titre de la boîte de
dialogue
boolean isModal() Retourne vrai si la boîte de dialogue
est modale
boolean isResizable() Indique si on peut redimensionner la
boîte de dialogue
void setModal(boolean b) Positionne la modalité

45
 Création d’une JDialog
Quelques méthodes de JDialog
Void setResizable (boolean Positionne la possibilité de
resizable)
redimensionner.
void setTitle(String title) Change le titre de la boîte
Indique comment la boîte de
dialogue daoit se comporter
quand l'utilisateur ferme la fenêtre.
void v peut avoir les valeurs suivantes :
setDefaultCloseOperation( • DO_NOTHING_ON_CLOSE : ne
int v) rien faire
• HIDE_ON_CLOSE : la fenêtre
devient invisible
• DISPOSE_ON_CLOSE :la fenêtre
est détruite
46
 Création d’une JDialog
Dialogue d’information
❑La classeJOptionPane fournit des façon simples de créer des dialogues
élémentaires modaux en spécifiant un message, un titre, une icône, et un
type de message ou un type d’option.
❑L’appel de la méthode showMessageDialog de la classeJOptionPane
permet de faire apparaître des messages :
JOptionPane d = new JOptionPane();
d.showMessageDialog(LaFentre,"le message","le titre", messageType);
❑Le type de message est l’une des valeurs suivantes :
JOptionPane.PLAIN_MESSAGE
JOptionPane.ERROR_MESSAGE
JOptionPane.INFORMATION_MESSAGE
JOptionPane.WARNING_MESSAGE
JOptionPane.QUESTION_MESSAGE
47
 Création d’une JDialog
Example
import javax.swing.*;
import java.awt.*;
public class BoiteMessage {
public static void main ( String args []) {
JFrame fenetre = new JFrame ("Une fenetre") ;
fenetre.setSize (300 , 200) ;
fenetre. setVisible (true);
JOptionPane.showMessageDialog(fenetre, "message\n
Attention","Information", JOptionPane.WARNING_MESSAGE);
}
}
48
 Création d’une JDialog
Dialogue de confirmation
❑L’appel de la méthode showConfirmDialog de la
classeJOptionPane permet de faire apparaître des
messages, avec demande de confirmation :
JOptionPane d = new JOptionPane();
int retour = d.showConfirmDialog(laFrame, "le
message", "le titre", messageType);

49
 Création d’une JDialog
❑L’option de message est l’une des valeurs suivantes :
JOptionPane.DEFAULT_OPTION
JOptionPane.YES_NO_OPTION
JOptionPane.YES_NO_CANCEL_OPTION
JOptionPane.OK_CANCEL_OPTION
❑La valeur retournée par l’appel de méthode est l’une
des trois suivantes :
OK_OPTION
NO_OPTION
CANCEL_OPTION 50
 Création d’une JDialog
❑Example
import javax.swing.*;
import java.awt.*;
public class BoiteMessage {
public static void main ( String args []) {
JFrame fenetre = new JFrame ("Une fenetre") ;
fenetre.setSize (300 , 200) ;
fenetre. setVisible ( true ) ;
JOptionPane.showConfirmDialog(fenetre,"OK -
Annuler", "titre", JOptionPane.OK_CANCEL_OPTION);
}
}
51
 Les conteneurs intermédiaires
❑Comme les conteneurs de premier niveau, les
conteneurs intermédiaires sont destinés à contenir des
objets d'une sous-classe de JComponent.
❑Les conteneurs intermédiaires sont utilisés pour
structurer les interfaces graphiques.
❑Les conteneurs intermédiaires peuvent contenir
d’autres conteneurs intermédiaires.
❑Swing comporte plusieurs conteneurs intermédiaire :
JPanel, JScrollPane, JSplitPane, JTabbedPane,
JToolBar, JInternalFrame, JLayeredPane, JRootPane, ..
52
 Les conteneurs intermédiaires
❑Quelques méthodes :

void associe au Conteneur l’objet de

setLayout(LayoutManager) placement passé en paramètre.
void add(Component) ajoute ce composant au Conteneur
sans désignation de zone lorsque
l’objet de placement n’en a pas
besoin (FlowLayout, GridLayout ou
GridBagLayout)
void ajoute ce composant au Conteneur
add(Component,Object) en utilisant une désignation de
zone qui dépend de l’objet de
placement qui a été associé à ce
Conteneur (int pour un
BorderLayout)
53
 Les conteneurs intermédiaires
❑Quelques méthodes :

void enlève ce composant du

remove(Component) Conteneur
void removeAll() enlève tous les composants du
Conteneur
Component Retourne le composant situé
locate(int,int) aux coordonnées
données en paramètre
Void permet de modifier la couleur
setBackground(Color.C) C.

54
 JPanel
❑Les panneaux (JPanel) sont les conteneurs intermédiaires les
plus simples.
❑Il est possible de placer les panneaux dans d'autres conteneurs,
qu'ils soient de premier niveau ou intermédiaires.
❑Création d'un JPanel:
❖JPanel() : Création d'un panneau avec gestionnaire de placement
par défaut.
❖JPanel(LayoutManager layout) : Création d'un panneau avec
layout comme gestionnaire de placement.
❑Exemple:
JPanel Panneau = new JPanel(); // On crée une nouvelle instance
de notre JPanel
fenetre.getContentPane().add( Panneau );//on ajoute le panneau à
la fenêtre 55
 JPanel
❑Exemple: Une fenêtre JFrame avec un panneau vert qui contient
le texte « Bonjour à tous! ».
import java.awt.Color;
import javax.swing.*;
public class TestJPanel {
public static void main(String args []) {
JFrame fenetre = new JFrame("Une fenetre JFrame avec
panneau");
fenetre.setSize(300,100); JPanel Panneau = new JPanel();
fenetre.getContentPane().add(Panneau);
Panneau.setBackground(Color.green ) ;
JLabel label = new JLabel("Bonjour à tous!");
Panneau.add(label );fenetre.setVisible(true);
}} 56
 Les composants atomiques
❑Un composant atomique est considéré comme étant une
entité unique.
❑Swing comporte plusieurs composants atomiques :
❖JButton, JRadioButton, JCheckBox,
❖List, menu
❖TextField, TextArea, Label
❖FileChooser, ColorChooser, …

57
 Les boutons
❑Les trois grands types de boutons utilisables en Swing sont:
❖les boutons classiques (JButton),
❖les boutons radio (JRadioButton) et
❖les cases à cocher (JCheckBox).
❑Tous héritent de la classe javax.swing.AbstractButton, qui
fournit un grand nombre de méthodes communes pour
personnaliser leur apparence.
❑En swing un bouton peut comporter du texte, et/ou une icône ou
un en ensemble d'icônes destinées à représenter les différents
états du bouton :
❖activé ou désactivé : définit si l'utilisateur peut cliquer dessus ;
❖pressé/sélectionné ou relâché/non sélectionné
58
 JButton
❑La classe JButton permet de définir des boutons sur
lesquels on peut cliquer.
❑Quelques méthodes de JButton :
JButton(String) Création d’un bouton avec définition
du texte contenu dans le bouton
JButton(ImageIcon) Création d’un bouton avec une
icone dans le bouton
JButton(String, ImageIcon) Création d’un bouton avec
définition du texte et d’une icône
dans le bouton
String getText() Retourner le texte contenu dans le
bouton
void setText(String) Défnir le texte contenu dans le bouton
59
 JButton
❑Exemple:
//On crée une nouvelle instance de notre JButton
JButton bouton = new JButton("Bouton 1");
//on ajoute le bouton au panneau
Panneau.add(bouton);

60
 JButton
❑Exemple : Une fenêtre avec deux boutons.
import javax.swing.*;
public class TestJPanel {
public static void main(String args []) {
JFrame fenetre = new JFrame( "Une fenetre JFrame avec
panneau" );
fenetre.setSize(300,100); JPanel Panneau = new JPanel();
fenetre.getContentPane().add(Panneau );
JButton bouton1 = new JButton("Bouton 1");
Panneau.add(bouton1); JButton bouton2 = new
JButton("Bouton 2");
Panneau.add(bouton2); fenetre.setVisible(true);
}}
61
 JButton
❑Exemple : Créer l’interface graphique ci-dessous.

❑Indication:
GridLayout grid=new GridLayout(5, 4); //On définit le layout à
utiliser sur le content pane 5 lignes sur 4 colonnes
Panneau.setLayout(grid);
62
 JButton
Solution:
import java.awt.Color;
import java.awt.GridLayout;
import javax.swing.*;
public class TestJPanel {
public static void main(String args []){
String[] buttons = {"C“, "Bck", "",
"close","7","8","9", "/", "4", "5", "6", "*", "1",
"2", "3", "-", "0", ".", "=", "+"};
JFrame fenetre = new JFrame( "Calculatrice" ); 63
 JButton
fenetre.setSize(350,300);
JPanel Panneau = new JPanel();
fenetre.getContentPane().add(Panneau);
Panneau.setLayout(new GridLayout(5, 4));
Panneau.setBackground(Color.LIGHT_GRAY);
for (int i = 0; i < buttons.length; i++)
Panneau.add(new JButton(buttons[i]));
fenetre.setVisible(true);
}
} 64
 JCheckBox
❑JCheckBox permet de définir des cases à cocher, qui peuvent être
sélectionnées ou non.
❑Les constructeurs de JCheckBox sont les suivants :

Constructeur Rôle
JCheckBox(String) précise l'intitulé
JCheckBox(String, boolean) précise l'intitulé et l'état
JCheckBox(Icon) spécifie l'icône utilisée
JCheckBox(Icon, boolean) précise l'intitulé et l'état du bouton
JCheckBox(String, Icon) précise l'intitulé et l'icône
JCheckBox(String, précise l'intitulé, une icône et l'état
Icon, boolean)
JCheckBox bouton1 = new JCheckBox("Bouton 1"); // On crée
une nouvelle instance de notre JCheckBox 65
Panneau.add(bouton1); //on ajoute le bouton à coucher au panneau
 JCheckBox
Exercice: Créer une fenêtre avec un panneau et deux
cases à cocher de type JCheckBox.

66
 JCheckBox
import javax.swing.*;
public class TestJCheckBox {
public static void main(String argv[]) {
JFrame f = new JFrame("Fenetre avec case à coucher");
f.setSize(300,100); JPanel pannel = new JPanel();
JCheckBox bouton1 = new JCheckBox("Case 1");
pannel.add(bouton1);
JCheckBox bouton2 = new JCheckBox("Case 2");
pannel.add(bouton2); f.getContentPane().add(pannel);
f.setVisible(true);
}
}
67
 JRadioButton
❑Le bouton radio de type JRadioButton permet à
l’utilisateur d’effectuer un choix de type oui/non.
JPanel panneau= new JPanel();
// On crée une nouvelle instance de notre JRadioButton
JRadioButton bouton1 = new JRadioButton("Bouton 1");
//on ajoute le bouton au panneau
panneau.add(bouton1);
❑Un groupe de boutons radio est encapsulé dans un objet
de type ButtonGroup.

68
 JRadioButton
❑Il faut ajouter tous les JRadioButton du groupe en
utilisant la méthode add() de la classe ButtonGroup.
ButtonGroup group = new ButtonGroup();
JRadioButton radio1 = new JRadioButton(“Bouton 1",
true);
JRadioButton radio2 = new JRadioButton(" Bouton 2");
group.add(radio1);
group.add(radio2);
panel.add(radio1);
panel.add(radio2);
69
 JRadioButton
❑ Lors de la sélection d'un bouton, c'est l'objet de type
ButtonGroup qui se charge de désélectionner le bouton
précédemment sélectionné dans le groupe.
❑Un groupe n'a pas l'obligation d'avoir un bouton
sélectionné.
❑La classe JRadioButton possède plusieurs
constructeurs :

70
 JRadioButton
Constructeur Rôle
JRadioButton() Créer un bouton non sélectionné sans
libellé
JRadioButton(Icon) Créer un bouton non sélectionné sans
libellé avec l'icône fournie en paramètre
JRadioButton(Icon, Créer un bouton sans libellé avec l'icône
boolean) et l'état fournis en paramètres
JRadioButton(String) Créer un bouton non sélectionné avec le
libellé fourni en paramètre
JRadioButton(String, Créer un bouton avec le libellé et l'état
boolean) fournis en paramètres
JRadioButton(String, Créer un bouton non sélectionné avec le
Icon) libellé et l'icône fournis en paramètres
JRadioButton(String, Créer un bouton avec le libellé, l'icône et
Icon, boolean) l'état fournis en paramètres
71
 JRadioButton
❑Exercice: Développer une classe TestJRadioButton, une
méthode config() et une méthode main() pour créer une
fenêtre avec un panneau et 3 boutons radio. La fenêtre
permet de faire le choix entre les boutons radio.

72
 JRadioButton
import java.awt.*; import javax.swing.*;
public class TestJRadioButton extends JFrame {
public void config() {
this.setTitle("Test bouton radio");
JPanel panel = new JPanel();
ButtonGroup group = new ButtonGroup();
JRadioButton radio1 = new JRadioButton("Bouton 1");
JRadioButton radio2 = new JRadioButton("Bouton 2");
JRadioButton radio3 = new JRadioButton("Bouton 3");
group.add(radio1); panel.add(radio1);

73
 JRadioButton
group.add(radio2); panel.add(radio2);
group.add(radio3); panel.add(radio3);
Container contentPane = this.getContentPane();
contentPane.add(panel);
this.setSize(300, 150);
this.setVisible(true);
}
public static void main(String args[]) {
TestJRadioButton app = new TestJRadioButton();
app.config();
}
}
74
 JRadioButton
group.add(radio2); panel.add(radio2);
group.add(radio3); panel.add(radio3);
Container contentPane = this.getContentPane();
contentPane.add(panel);
this.setSize(300, 150);
this.setVisible(true);
}
public static void main(String args[]) {
TestJRadioButton app = new TestJRadioButton();
app.config();
}
}
75
 JTextField
❑Un JTextField est un composant qui permet d’écrire du texte.
❑Un JTextField a une seul ligne contrairement au JTextArea
❑Le JPasswordField permet de cacher ce qui est écrit
❑Quelques méthodes de JTextField :
void setText( String s) Affecte le texte du JTextField.
void Affecte l'orientation du composant :
setComponentOrientation ComponentOrientation.LEFT_TO_
(int o) RIGHT ou
ComponentOrientation.RIGHT_T
O_LEFT
void Affecte l'alignement horizontal
setHorizontalAlignment(i ( JTextField.LEFTou
nt a) JTextField.RIGHT) 76
 JTextField
void setColumns(int Affecte le nombre de colonnes,
nc) qui est utilisé pour calculer la
taille préférée.
void setFont(font f) Affecte la police du JTextField.
JTextField(String) qui la crée avec un contenu initial
JTextField(String,int qui la crée avec un contenu
) initial et définit le nombre de
colonnes
void pour associer l’objet qui traitera
addActionListener( les modifications du texte
Action Listener)

77
 JTextField
❑Lorsque l’on saisit du texte dans un tel composant celui-
ci adapte sa taille au texte saisi au fur et à mesure. Ce
comportement n’est pas toujours souhaitable, on peut
l’éviter en lui définissant une taille préférentielle par sa
méthode setPreferredSize et une taille minimale par sa
méthode SetMinimumSize
❑Exemple:
JTextField tfFName = new JTextField(20);
JLabel label= new JLabel("Nom:");

78
 JTextField

Exercice : Écrire un programme qui permet

à l’utilisateur de saisir des caractères dans un
champ texte.

79
 JTextField
import java.awt.FlowLayout;
import javax.swing.*;
public class TestJTextField extends JFrame{
public TestJTextField(){
setTitle("Une fenetre avec zone de texte");
setSize(200,200);
setLayout(new FlowLayout());
JPanel panneau = new JPanel();
JLabel label1 = new JLabel("Nom:" );
JLabel label2 = new JLabel("prénom:" ); 80
 JTextField
JTextField texte1=new JTextField (10);
JTextField texte2=new JTextField (10);
add(panneau);
add(label1);add(texte1);
add(label2);add(texte2);
setVisible(true);
}
public static void main(String[] args){
new TestJTextField();
}
} 81
 JLabel
❑Le composant JLabel permet d'afficher un texte (libellé), une
icône (image) ou les deux à la fois.
❑Le texte du composant JLabel n'est pas éditable par l'utilisateur.
Méthodes Description
JLabel(Icon) Créer une instance JLabel, l’initialiser pour
JLabel(Icon, int) avoir text/image/alignment spécifiés.
JLabel(String) L’argument int spécifie l’alignment horizontal
JLabel(String, du contenu du label. L’ alignment horizontal
Icon, int) doit être un des constants définies dans
JLabel(String, l’interface SwingConstants (que JLabel
int) implemente): LEFT, CENTER, RIGHT,
JLabel() LEADING, or TRAILING. Pour une
localisation facile, il est recommandé d’utiliser
LEADING et TRAILING, à la place de LEFT
et RIGHT.
 JLabel
❑La création d'icône fait appel à la classe ImageIcon qui possède
un constructeur permettant de lire l'icône à partir d'un fichier
au format GIF (y compris les images animées GIF89A) ou JPEG
ou PNG.
❑Exemples:
JLabel lNom = new JLabel("Nom");
Icon image1 = new ImageIcon("H:/pictures/image1.gif");
JLabel lImage = new JLabel(image1);
JLabel lCombi = new JLabel("Texte", image1,
JLabel.CENTER);
 JLabel
package javaapplication46;
import javax.swing.JFrame;import javax.swing.JLabel;
import javax.swing.JPanel;import java.awt.FlowLayout;
public class ExempleJLabel {
public static void main(String[] args) {
JFrame frame = new JFrame("Exemple de JLabel");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 200);
JPanel panel = new JPanel(new FlowLayout());
JLabel label1 = new JLabel("Label 1");
JLabel label2 = new JLabel("Label 2");
JLabel label3 = new JLabel("Label 3");
panel.add(label1); panel.add(label2); panel.add(label3);
frame.add(panel); frame.setVisible(true);
}
}
 JTextArea
❑JTextArea affiche et édite plusieurs lignes de texte
simple non formaté.
❑Un utilisateur peut taper n'importe quel nombre de
lignes de texte en utilisant la touche Entrée pour les
séparer. Chaque ligne se termine par un caractère de
retour de ligne '\n'.
❑Exemples :
❑Ce constructeur de JTextArea spécifie 8 lignes et 40
colonnes pour la zone.
JTextArea zone = new JTextArea(8, 40);
❑On ajoute une barre de défilement (JScrollPane) à la
zone de texte dans un panneau avec :
JScrollPane ascenceur = new JScrollPane(zone);
 JTextArea
import java.awt.FlowLayout;
import javax.swing.*;
public class composantstext extends JFrame{
JTextArea zone = new JTextArea(8, 40);
JScrollPane ascenceur = new JScrollPane(zone);
private JPanel pan = new JPanel();
public composantstext() {
setTitle("TextArea"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan.setLayout(new FlowLayout());
pan.add(ascenceur);
this.add(pan);
this.setVisible(true);
}
}
 JList
❑La classe JList permet d'afficher une liste d'objets, et
offre à l'utilisateur la possibilité de sélectionner un ou
plusieurs objets de la liste.
❑Un JList peut être créé à partir d'un tableau d'objets,
ou à partir d'un Vector, mais si on veut une liste qui peut
être mise à jour par programme, il faut utiliser un
ListModel.
❑La classe JList possède plusieurs constructeurs :

87
 JList

Constructeur Rôle
JList() Crée un Jlist vide.
JList(Object [] Crée un Jlist qui affiche les données
donnees) continues dans le tableau donnees.
JList(Vector v) Crée un Jlist qui affiche les données
continues dans le vecteur v.
JList (ListModel l) Crée un Jlist qui affiche les données
contenues dans le ListModel l.

88
 JList
❑Quelques méthodes de JList :

Méthode Rôle
int getSelectionMode() Retourne le mode de
sélection des données.
void setSelectionMode( int sm) Affecte le mode de sélection
des données.
int[] getSelectedIncices() Retourne les indices des
items sélectionnés.
void setSelectedIndex(int i) Affecte l'indice de l'item
sélectionné.

89
 JList
❑Quelques méthodes de JList :
Object getSelectedValue() Retourne la valeur de l'item
sélectionné.
Object[] Retourne un tableau des items
getSelectedValues() sélectionnés.
ListModel getModel() Retourne le modèle de
données affiché par le JList.
void setModel(ListModel Lenouveau modèle de données
lm) affiché par le JList est lm.
ListCellRenderer Retourne l'objet qui gère le
getCellRenderer() rendu des items.

90
 JList
❑Exemple:
// Liste de données à afficher
String choix [] = {“choix1”, “choix 2”, “choix 3”};
// On crée une nouvelle instance de notre Jlist avec des
entrées.
JList liste = new JList(choix);

91
 JList
Exercice: Créer une fenêtre avec un
panneau et la liste des choix suivante.

92
 JList
import javax.swing.*;
public class TestJList {
public static void main(String[] args) {
String Jours[] = {"Lundi", "Mardi", "Mercredi",
"Jeudi", "Vendredi", "Samedi", "Dimanche"};
JFrame fenetre = new JFrame();
fenetre.setTitle("Test JList");
fenetre.setSize(300, 300);
JPanel panneau = new JPanel();

93
 JList
JPanel panneau = new JPanel();
JLabel label = new JLabel("Selectionner le jour :");
panneau.add(label);
JList liste = new JList(Jours);
panneau.add(liste);
fenetre.add(panneau);
fenetre.setVisible(true);
}
}

94
 JMenuBar
❑Ce composant permet de créer une barre de menu.
❑Les menus de Swing proposent certaines caractéristiques
intéressantes en plus de celles proposées par un menu
standard :
❖les éléments de menu peuvent contenir une icône
❖les éléments de menu peuvent être de type bouton radio ou
case à cocher
❖les éléments de menu peuvent avoir des raccourcis clavier
(accelerators)
❑Les menus sont mis en œuvre dans Swing avec un ensemble
de classe :
❖JMenuBar : encapsule une barre de menus
95
 JMenuBar
❖JMenu : encapsule un menu
❖JMenuItem : encapsule un élément d'un menu
❖JCheckBoxMenuItem : encapsule un élément d'un
menu sous la forme d'une case à cocher
❖JRadioButtonMenuItem : encapsule un élément d'un
menu sous la forme d'un bouton radio
❖JSeparator : encapsule un élément d'un menu sous la
forme d'un séparateur
❖JPopupMenu : encapsule un menu contextuel

96
 JMenuBar
❑Exemple :
// On crée une nouvelle instance de notre JMenuBar
JMenuBar BarreDeMenus=new JMenuBar();
// On crée une nouvelle instance de notre JMenu
JMenu menu = new JMenu("Menu");
// On ajoute JMenu à la JMenuBar
BarreDeMenus.add(menu);
// On crée une nouvelle instance de notre JMenuItem
JMenuItem menuItem1 = new JMenuItem("New");
// On ajoute un sous-menu
Menu1.add(menuItem1);
// On place la barre de menus dans la fenêtre.
setJMenuBar(BarreDeMenus); 97
 JMenuBar

Exercice d’application: Créer la fenêtre

suivante.

98
 JMenuBar
import java.awt.Color;
import javax.swing.*;
public class CreationDunBarreDeMenus {
public static void main(final String args[]) {
JFrame fenetre = new
JFrame("Exemple d'une barre de Menus");
fenetre.setSize(350, 250);
fenetre.getContentPane().setBackground
(Color.WHITE); 99
 JMenuBar
JMenuBar BarreDeMenus = new JMenuBar();
JMenu Menu1 = new JMenu("Fichier");
BarreDeMenus.add(Menu1);
JMenuItem menuItem1 = new JMenuItem("Nouveau");
Menu1.add(menuItem1);
JMenuItem menuItem2 = new JMenuItem("Ouvrir");
Menu1.add(menuItem2);
MenuItem menuItem3 = new JMenuItem("Enregistrer");
Menu1.add(menuItem3);
100
 JMenuBar
JMenuItem menuItem4 = new JMenuItem("Quitter");
Menu1.add(menuItem4);
JMenu Menu2 = new JMenu("Edition");
BarreDeMenus.add(Menu1);
JMenu Menu3 = new JMenu("Aide ?");
BarreDeMenus.add(Menu1);
BarreDeMenus.add(Menu2);
BarreDeMenus.add(Menu3);
fenetre.setJMenuBar(BarreDeMenus);
fenetre.setVisible(true);
}
}
101
Le positionnement des
composants

102
Le positionnement des composants
❑Lorsqu'on intègre un composant graphique dans un
conteneur, il n'est pas nécessaire de préciser son
emplacement car il est déterminé de façon
automatique.
❑On peut modifier la mise en page en utilisant un
gestionnaire de mise en page (Layout Manager) qui
définit la position de chaque composant inséré.
❑Java propose plusieurs layout : FlowLayout,
BorderLayout, CardLayout, GridBagLayout,
GridLayout,
❑Chaque layout manager implémente l'interface
java.awt.LayoutManager.
103
 Le positionnement des composants
❑Il est possible d'utiliser plusieurs gestionnaires de mise
en forme pour définir la présentation des composants.
❑La classe FlowLayout est utilisée par défaut pour la
classe Panel et la classe BorderLayout pour Frame et
Dialog.
❑Pour affecter une nouvelle mise en page, il faut utiliser
la méthode setLayout() de la classe Container.

104
 FlowLayout
❑Le gestionnaire FlowLayout (mise en page flot) place
les composants ligne par ligne de gauche à droite.
❑Chaque ligne est complétée progressivement jusqu'à
être remplie, puis passe à la suivante.
❑Chaque ligne est centrée par défaut. C'est la mise en
page par défaut des applets.
❑Il existe plusieurs constructeurs :

105
 FlowLayout

Constructeur Rôle
FlowLayout( );
FlowLayout( int Permet de préciser l'alignement
align); des composants dans le conteneur
(CENTER, LEFT, RIGHT ... ).
Par défaut, align vaut CENTER
FlowLayout( int Permet de préciser l'alignement et
align, int hgap, l'espacement horizontal et vertical
int vgap); dont la valeur par défaut est 5.

106
 FlowLayout
❑Exercice : Écrire une classe TestFlowLayout avec un
constructeur et une méthode main.
❖Modifier le constructeur pour réaliser une interface
graphique comportant une fenêtre principale et trois
boutons positionnés en utilisant la classe FlowLayout.
❖Modifier la méthode main pour afficher la fenêtre
avec les boutons.

107
 FlowLayout
❑Exercice : Écrire une classe TestFlowLayout avec un
constructeur et une méthode main.
❖Modifier le constructeur pour réaliser une interface
graphique comportant une fenêtre principale et trois
boutons positionnés en utilisant la classe FlowLayout.
❖Modifier la méthode main pour afficher la fenêtre
avec les boutons.

108
 FlowLayout
import java.awt.*; import javax.swing.JFrame;
public class TestFlowLayout extends JFrame {
public TestFlowLayout() {
setTitle(" Test FlowLayout"); setSize(300, 150);
setLayout(new FlowLayout());
add(new Button("Bouton 1")); add(new Button("Bouton
2"));
add(new Button("Bouton 3")); setVisible(true);
}
public static void main(String[] args) {
new TestFlowLayout();
}}
109
 BorderLayout
❑La disposition des composants est commandée par
une mise en page en bordure qui découpe la surface en
cinq zones : North, South, East, West, Center.
❑On peut librement utiliser une ou plusieurs zones.
❑Il existe plusieurs constructeurs :

110
 BorderLayout
Constructeur Rôle
BorderLayout( )
BorderLayout (int Permet de préciser
hgap, int vgap) l'espacement horizontal et
vertical des composants.

❑ Exemple :
setLayout(new BorderLayout());
add("North", new Button(" bouton haut "));

111
 BorderLayout
Exercice d’application : Créer la fenêtre
suivante.

112
 BorderLayout
import java.awt.*;
import javax.swing.*;
public class TestBorderLayout extends JFrame {
public TestBorderLayout() {
super();
setTitle("Test BorderLayout");
setSize(300, 200);
setLayout(new BorderLayout());
add("North", new Button(" bouton haut "));
113
 BorderLayout
add("South", new Button(" bouton bas "));
add("West", new Button(" bouton gauche "));
add("East", new Button(" bouton droite "));
add("Center", new Button(" bouton milieu "));
pack(); setVisible(true);
}
public static void main(String[] args) {
new TestBorderLayout();
}
} 114
 GridLayout
❑Ce gestionnaire établit un réseau de cellules
identiques qui forment une sorte de quadrillage
invisible : les composants sont organisés en lignes et en
colonnes.
❑Les éléments insérés dans la grille ont tous la même
taille.
❑Les cellules du quadrillage se remplissent de gauche à
droite ou de haut en bas.
❑Il existe plusieurs constructeurs :

115
 GridLayout
Constructeur Rôle
GridLayout( int, int ); Les deux premiers entiers
spécifient le nombre de lignes
ou de colonnes de la grille.
GridLayout( int, int, permet de préciser en plus
int, int ); l'espacement horizontal et
vertical des composants.

❑Exemple:
setLayout(new GridLayout(1,2));
add(new Button("bouton 1"));
add(new Button("bouton 2")); 116
 GridLayout
Exercice d’application : Créer la fenêtre suivante
en utilisant le gestionnaire GridLayout.

117
 GridLayout
import java.awt.*;
import javax.swing.JFrame;
public class TestGridLayout extends JFrame {
public TestGridLayout() {
setTitle(" Test GridLayout ");
setSize(300, 150);
setLayout(new GridLayout(2, 3));
add(new Button("bouton 1"));
add(new Button("bouton 2"));
118
 GridLayout
add(new Button("bouton 3"));
add(new Button("bouton 4"));
add(new Button("bouton 5 tres long"));
add(new Button("bouton 6"));
setVisible(true);
}
public static void main(String[] args) {
new TestGridLayout();
}
} 119
 Remarques
L'idéal est de combiner
l'ensemble de ces
gestionnaires au travers de
panneaux intermédiaires
(JPanel) afin d'obtenir
l'apparence désirée :

120
Remarques

121
 Solution
Au début, on utilise un pan avec BorderLayout avec les
bordures Centre, Est et Sud comme illustré sur la figure
suivante:
import java.awt.BorderLayout;
import javax.swing.*;
public class ExempleLayouts extends JFrame{
private JButton sud= new JButton("Sud");
private JButton centre= new JButton("Centre");
private JButton est= new JButton("Est");
private JPanel pan1 = new JPanel();
122
 Solution
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.add(sud, BorderLayout.SOUTH);
pan1.add(centre, BorderLayout.CENTER);
pan1.add(est, BorderLayout.EAST);
this.add(pan1);
setVisible(true);
}
public static void main(String[] args) {
new ExempleLayouts();
}
} 123
 Solution
Après, on ajoute un autre pan BorderLayout avec les
bordures Nord, Centre et Sud2 et on le place au centre
du premier pan:

124
 Solution
import java.awt.BorderLayout; import javax.swing.*;
public class ExempleLayouts extends JFrame{
private JButton sud1= new JButton("Sud1");
private JButton sud2= new JButton("Sud2");
private JButton centre= new JButton("Centre");
private JButton est= new JButton("Est");
private JButton nord= new JButton("Nord");
private JPanel pan1 = new JPanel();
private JPanel pan2 = new JPanel();
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
125
 Solution
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.setLayout(new BorderLayout());
pan1.add(sud1, BorderLayout.SOUTH);
pan1.add(pan2);// on ajoute pan 2 au centre de pan1
pan1.add(est, BorderLayout.EAST);
this.add(pan1);
pan2.setLayout(new BorderLayout());
pan2.add(nord, BorderLayout.NORTH);
pan2.add(centre, BorderLayout.CENTER);
pan2.add(sud2, BorderLayout.SOUTH);
setVisible(true);
}
} 126
 Solution
❑ Après, on ajoute un autre pan GridLayout avec 5
lignes et 1 colonne et on le place au Nord du deuxième
pan :

127
 Solution
import java.awt.*; import javax.swing.*;
public class ExempleLayouts extends JFrame{
//le début reste inchangé
private JPanel pan3 = new JPanel();
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.setLayout(new BorderLayout());
pan1.add(sud1, BorderLayout.SOUTH);
pan1.add(pan2);
pan1.add(est, BorderLayout.EAST);
this.add(pan1);
128
 Solution
Après, on ajoute un autre pan4 de type GridLayout avec
9 lignes et 1 colonne et on le place à l’est de pan1:

129
 Solution
import java.awt.*; import javax.swing.*;
public class ExempleLayouts extends JFrame{
//on ne change rien ici
private JPanel pan4 = new JPanel();
public ExempleLayouts() {
setTitle("Mélange de Layouts"); setSize(300, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
pan1.setLayout(new BorderLayout());
pan1.add(sud1, BorderLayout.SOUTH);
pan1.add(pan2);
//on ajoute pan 4à l’Est de pan1
pan1.add(pan4, BorderLayout.EAST);
this.add(pan1); 130
 Solution
//les codes de pan2 et pan3 reste inchangé
pan4.setLayout(new GridLayout(9,1));
pan4.add(new JButton("Tennis"));
pan4.add(new JButton("Squash"));
pan4.add(new JButton("Natation"));
pan4.add(new JButton("Athlétisme"));
pan4.add(new JButton("Randonnée"));
pan4.add(new JButton("Foot"));
pan4.add(new JButton("Basket"));
pan4.add(new JButton("Volley"));
pan4.add(new JButton("Pelanque"));
setVisible(true);
}}
131
 Solution
Après, on ajoute deux autres pan: pan5 et pan6 de type
FlowLayout et on les place au sud de pan2 et pan1
respectivement:

132
 Solution Programme complet:
import java.awt.*;
import javax.swing.*;
public class ExempleLayouts extends JFrame{
private JButton sud1= new JButton("Sud1");
private JButton sud2= new JButton("Sud2");
private JButton centre= new JButton("Centre");
private JButton est= new JButton("Est");
private JButton nord= new JButton("Nord");
private JPanel pan1 = new JPanel();
private JPanel pan2 = new JPanel();
private JPanel pan3 = new JPanel();
133
 Solution Programme complet:
pan2.setLayout(new BorderLayout());
pan2.add(pan3, BorderLayout.NORTH);
pan2.add(centre, BorderLayout.CENTER);
// ajouter pan5 au sud de pan2
pan2.add(pan5, BorderLayout.SOUTH);
pan3.setLayout(new GridLayout(5,1));
pan3.add(new JButton("Nom1"));
pan3.add(new JButton("Nom2"));
pan3.add(new JButton("Prenom1"));
pan3.add(new JButton("Prenom2"));
pan3.add(new JButton("Adresse"));
134
 Solution Programme complet:
pan4.setLayout(new GridLayout(9,1));
pan4.add(new JButton("Tennis"));
pan4.add(new JButton("Squash"));
pan4.add(new JButton("Natation"));
pan4.add(new JButton("Athlétisme"));
pan4.add(new JButton("Randonnée"));
pan4.add(new JButton("Foot"));
pan4.add(new JButton("Basket"));
pan4.add(new JButton("Volley"));
pan4.add(new JButton("Pelanque")); 135
 Solution Programme complet:
pan5.setLayout(new FlowLayout());
pan5.add(new JButton("Sexe"));
pan5.add(new JButton("Homme"));
pan5.add(new JButton("Femme"));
pan6.setLayout(new FlowLayout());
pan6.add(new JButton("OK"));
pan6.add(new JButton("Annuler"));
setVisible(true);
}
public static void main(String[] args) {
new ExempleLayouts();
}
}
136
Gestion des Evénements

137
 Gestion des Evénements
❑N'importe quelle interface graphique doit interagir
avec l'utilisateur et donc réagir à certains événements.
❑Les événements utilisateurs sont gérés par plusieurs
interfaces EventListener.
❑Les interfaces EventListener permettent de définir les
traitements en réponse à des événements utilisateurs
généré par un composant.

138
 Gestion des Evénements
❑Une classe doit contenir une interface auditrice pour
chaque type d'événements à traiter :
❖ActionListener : clic de souris ou enfoncement de la
touche Enter
❖ItemListener : utilisation d'une liste ou d'une case à
cocher
❖MouseMotionListener : événement de souris
❖WindowListener : événement de fenêtre

139
 Gestion des Evénements
❑Les événements sémantiques
❑Dans la dernière colonne de ce tableau, les termes
génériques Boutons et Menus désignent les classes
suivantes
❖Boutons : JButton, JCheckBox, JRadioButton,
❖Menus : JMenu, JMenuItem, JCheckBoxMenuItem,
JRadioButtonMenuItem.

140
Gestion des Evénements

141
Gestion des Evénements

142
ActionListener : Réagir aux clics sur un JButton
L'ajout d'une interface EventListener impose plusieurs
ajouts dans le code :
1) La classe doit déclarer qu'elle utilisera une ou plusieurs
interfaces d'écoute :
❑Exemple :
//le listener est la classe test
public class TestListner extends JFrame implements
ActionListener{
❑Pour déclarer plusieurs interfaces, il suffit de les séparer
par des virgules.
public class TestListner extends JFrame implements
ActionListener, MouseListener {
143
ActionListener : Réagir aux clics sur un JButton
2) Appel à la méthode addXXX() pour enregistrer
l'objet qui gérera les événements XXX du composant.
❑Il faut configurer le composant pour qu'il possède un
«écouteur» pour l'événement utilisateur concerné.
❑Exemple : création d'un bouton capable de réagir à un
événement:
Button b = new Button("boutton");
b.addActionListener(this);

144
ActionListener : Réagir aux clics sur un JButton
❑Création de l'objet de la classe Button et appelle sa
méthode addActionListener().
❑La méthode addActionListener() permet de préciser
la classe qui va gérer l'événement utilisateur de type
ActionListener du bouton.
❑La classe doit impérativement implémenter l'interface
de type EventListener correspondante soit dans cet
exemple ActionListener.
❑L'instruction this indique que la classe elle même
recevra et gérera l'événement utilisateur.

145
ActionListener : Réagir aux clics sur un JButton
3) Implémenter les méthodes déclarées dans les
interfaces :
❑Chaque auditeur possède des méthodes différentes qui
sont appelées pour traiter leurs événements.
❑Par exemple, l'interface ActionListener envoie des
événements à une méthode nommée actionPerformed(
).
❑Exemple:
public void actionPerformed(ActionEvent e) {
//insérer ici le code de la méthode
};
146
 ActionListener : Réagir aux clics sur un JButton
❑Pour identifier le composant qui a généré l'événement, il
faut utiliser la méthode getActionCommand() de l'objet
ActionEvent fourni en paramètre de la méthode :
❑Exemple:
String composant = e.getActionCommand();
❑La méthode getActionCommand() renvoie une chaîne de
caractères. Si le composant est un bouton, alors il renvoie le
texte du bouton, si le composant est une zone de saisie, c’est
le texte saisi qui sera renvoyé (il faut appuyer sur «Entrer»
pour générer l'événement), etc
...
❑La méthode getSource() renvoie l'objet qui a généré
l'événement. Cette méthode est plus sûre que la précédente.
147
 ActionListener : Réagir aux clics sur un JButton
❑Exemple:
Button b = new Button(" bouton ");
...
void public actionPerformed(actionEvent e) {
Object scan = e.getSource();
if (scan== b)
// action a effectuer
}

148
 ActionListener : Réagir aux clics sur un JButton
❑Exemple :
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class SwingAction extends JFrame implements
ActionListener {
public SwingAction() {
this.setLayout(new FlowLayout());
this.getContentPane().setBackground(Color.green);
JButton b1 = new JButton("boutton1");
JButton b2 = new JButton("boutton2");
JButton b3 = new JButton("boutton3");
149
ActionListener : Réagir aux clics sur un JButton
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
this.add(b1);
this.add(b2);
this.add(b3);
this.setTitle("Les listes déroulantes : combobox");
this.setSize(300, 200);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

150
ActionListener : Réagir aux clics sur un JButton
@Override
public void actionPerformed(ActionEvent evt) {
String composant = evt.getActionCommand();
if (composant.equals("boutton1")) {
getContentPane().setBackground(Color.blue);
} else if (composant.equals("boutton2")) {
getContentPane().setBackground(Color.red);
} else if (composant.equals("boutton3")) {
getContentPane().setBackground(Color.YELLOW);
}
}
151
 ActionListener : Réagir aux clics sur un JButton
public static void main(String[] args) {
new SwingAction();
}
}

152
 ActionListener : Réagir aux clics sur un JButton
public static void main(String[] args) {
new SwingAction();
}
}

153
 ItemListener
❑ Interface ItemListener : Cette interface permet de réagir à la
sélection de cases à cocher et de liste d'options
➢ Pour qu'un composant génère des événements, il faut utiliser
la méthode addItemListener()
JCheckBox cb = new JCheckBox("choix", true);
cb.addItemListener(this);
➢ Ces événements sont reçus par la méthode
itemStateChanged() qui attend un objet de type ItemEvent en
argument
➢ Pour déterminer si une case à cocher est sélectionnée ou
inactive, utiliser la méthode getStateChange() avec les constantes
ItemEvent.SELECTED ou ItemEvent.DESELECTED.
 ItemListener
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class SwingCheckBoxExample extends JFrame
implements ItemListener {
JCheckBox cb;
JLabel resultLabel;
public SwingCheckBoxExample() {
this.setLayout(new FlowLayout());
this.getContentPane().setBackground(Color.lightGray);
cb = new JCheckBox("choix", true);
cb.addItemListener(this);
155
 ItemListener
resultLabel = new JLabel("CheckBox is selected");
this.add(cb);
this.add(resultLabel);
this.setTitle("Swing CheckBox Example with JLabel");
this.setSize(300, 150);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

156
 ItemListener
@Override
public void itemStateChanged(ItemEvent e) {
if (e.getSource() == cb) {
if (cb.isSelected()) {
resultLabel.setText("CheckBox is selected");
} else {
resultLabel.setText("CheckBox is not selected");
}
}
}

157
 ItemListener
public static void main(String[] args) {
new SwingCheckBoxExample();
}
}

158
 TextListener
❑Interface TextListener : Cette interface permet de
réagir au modification de zone de saisie ou de texte.
❑ La méthode addTextListener() permet à un composant
de texte de générer des événements utilisateur.
❑ La méthode textValueChanged() reçoit les événements

159
 TextListener
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
public class SwingTextListenerExample extends JFrame {
JTextField textField;
JLabel statusLabel;
public SwingTextListenerExample() {
// Set layout and background color
this.setLayout(new FlowLayout());
this.getContentPane().setBackground(Color.lightGray);
textField = new JTextField(20); 160
 TextListener
// Add a DocumentListener to listen for text changes
textField.getDocument().addDocumentListener(new DocumentListener() {
@Override
public void insertUpdate(DocumentEvent e) {
updateStatus();
}
@Override
public void removeUpdate(DocumentEvent e) {
updateStatus();
}
@Override
public void changedUpdate(DocumentEvent e) {
updateStatus();
}
161
 TextListener
private void updateStatus() {
statusLabel.setText("Saisi = " + textField.getText());
}
});
// Create a JLabel to display the status
statusLabel = new JLabel("Saisi = ");
// Add components to the frame
this.add(textField);
this.add(statusLabel);

162
 TextListener
this.setTitle("Swing TextListener Example");
this.setSize(300, 150);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
// Create and display the frame
new SwingTextListenerExample();
}
}

163