Mme Khadija Bouzaachane

IHM
Mme Khadija Bouzaachane

Awt & swing
 AWT (Abstract
Window Toolkit). Programme
DB
 Situés dans le
paquetage java.awt
Interface Utilisateur
Rôles d’une interface utilisateur:

• montrer le résultat de l’exécution
• permettre à l’utilisateur d’interagir
Composants légers de Swing
 SWING()
 Un composant graphique léger (en anglais, LightWeight GUI
component) est un composant graphique indépendant du
gestionnaire de fenêtre local.
 Les composants Swing sont situés dans le paquetage javax.swing
et ses sous paquetages.
 Ils portent des noms similaires à leurs correspondants de AWT
précédés d'un J.
– JFrame, JPanel, JTextField, JButton, JCheckBox, JLabel, etc.
– Tous les composants de Swing, exceptés JApplet, JDialog,
JFrame et JWindow sont des composants légers.
Le schéma Modèle-Vue-Contrôleur (MVC)
Le schéma Modèle-Vue-Contrôleur (MVC) est un mode de

conception d’applications graphiques préconisant la distinction
des données, de leur apparence graphique et des traitements
qui peuvent être effectués. Un composant graphique est
décomposé en trois parties :
 Le modèle contenant ses données et son état courant ;
 La vue qui correspond à son apparence graphique ;
 Le contrôleur associant des traitements à des événements
pouvant se produire au sein du composant.
La décomposition MVC du bouton ci-dessous (instance de la

classe JButton) est constituée :
 Du modèle contenant la chaîne de caractères “Quitter” ;

 De la vue constituée d’un rectangle gris à bord noir, d’une
taille donnée, à une position donnée et au sein duquel est écrite
la chaîne de caractères du modèle ;
 Du contrôleur implémentant le traitement à effectuer lors d’un
click sur le bouton, c’est-à-dire l’appel à l’instruction de
fermeture de la fenêtre.
7
Tous les composants graphiques du package SWING ont un modèle,

une vue et peuvent avoir plusieurs contrôleurs.
Pour faciliter la programmation, certaines classes (tel que JButton)

encapsulent le modèle et la vue dans une seule classe disposant de
méthodes d’accès et de modifications des données ou de
l’apparence. Dans ces cas-là, un modèle par défaut est utilisé.
Composition d’une interface graphique
Une fenêtre peut donc être construite selon le principe suivant :

Le conteneur(Container):
 En plus des caractéristiques d’un composant simple, un container

contient un ensemble de composants ainsi que des contraintes sur
leur disposition.
 L’ajout d’un composant à un container se fait par une méthode
add().
 Il existe plusieurs méthodes add() acceptant des paramètres
d’entrée différents.
 La méthode à utiliser dépend du type de disposition choisi.
Liste des principaux conteneurs Swing
Conteneurs fenêtres.
14
15
16
Les Composants graphiques de Swing
Composer une fenêtre

Voici les étapes à suivre:
 Créer une fenêtre (1)
 Créer un ou des composants intermédiaires (2)
 Pour JFrame, un JPanel est associé implicitement
(ContentPane)
 Créer des composants de base (3)
 Insérer (3) dans (2)
 Insérer (2) dans (1) (s’ils ne sont pas déjà associés)
 Afficher
 Gérer les évènements
Les Composants graphiques de Swing
Composants intermédiaires
• Utilisés pour organiser ou positionner d’autres
composants (de base)
– JPanel utilisé pour regrouper d’autres composants
– JScrollPane fournir une vue avec scroll bars
– JSplitPane divise en 2 composants
–…
JPanel p = new JPanel();

p.add(new JButton("on"));
p.add(new JButton("off"));
La classe JFrame
La classe JFrame
Fenetre.java PremiereFenetre.java
import javax.swing.JFrame; public class PremiereFenetre {
public class Fenetre extends JFrame { public static void main(String[] args){
public Fenetre(){ JFrame f = new Fenetre();
this.setTitle("My first window"); f.setVisible(true);
this.setSize(600, 600); }
this.setLocationRelativeTo(null); }
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLO
SE);
}
}
La classe JFrame
Action sur les caractéristiques d’une fenêtre

Positionner la fenêtre à l'écran: setLocation()
La méthode setLocation(int x, int y) nous permet de positionner la fenêtre
dans l’écran.
Les coordonnées, exprimées en pixels, sont basées sur un repère dont
l'origine est représentée par le coin supérieur gauche.
Exemple
f. setLocation(10,40);
// le coin supérieur gauche de la fenêtre
// est placé au pixel de coordonnées 10, 40
La classe JFrame

Fixer les dimensions et positionner la fenêtre à l'écran
La méthode setBounds() nous permet de fixer non seulement les dimensio
mais aussi la position de la fenêtre à l’écran.
Exemple
f.setBounds (10, 40, 300, 200) ;
// le coin supérieur gauche de la fenêtre
// est placé au pixel de coordonnées 10, 40
// et ses dimensions seront de 300 * 200 pixels
La classe JFrame

Empêcher le redimensionnement de la fenêtre
Pour cela, il suffit d'invoquer la méthode setResizable(boolean b) : false
empêche le redimensionnement tandis que true l'autorise.
Exemple
f.setResizable(true);
f.setResizable(false);
La classe JFrame

Garder la fenêtre au premier plan
Il s'agit là encore d'une méthode qui prend un booléen en paramètre.
Passer true laissera la fenêtre au premier plan quoi qu'il advienne, false
annulera cela. Cette méthode est setAlwaysOnTop(boolean b).
La classe JPanel
L’objet JPanel
Nous allons utiliser un JPanel, composant de type conteneur dont la
vocation est d'accueillir d'autres objets de même type ou des objets de
type composant (boutons, cases à cocher…).
Voici les étapes à suivre :
1. Importer la classe javax.swing.JPanel dans notre classe héritée de
JFrame.
2. Instancier un JPanel puis lui spécifier une couleur de fond pour
mieux le distinguer.
3. Avertir notre JFrame que ce sera notre JPanel qui constituera son
ContentPane.
La classe JPanel
L’objet Jpanel
import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Fenetre {
public void main(String args[]){
this.setTitle("My first window");
this.setSize(600, 600);
this.setLocationRelativeTo(null);// pour centrer la fenêtre
//Instanciation d'un objet JPanel
JPanel pan = new JPanel();
//Définition de sa couleur de fond
pan.setBackground(Color.ORANGE);
//On prévient notre JFrame que notre JPanel sera son ContentPane
this.setContentPane(pan);
this.setVisible(true);
}}
La classe JPanel
L’objet Jpanel
Exemple 2
import java.awt.Color;
import javax.swing.JPanel;
public class Fenetre extends JFrame {
public Fenetre(){
this.setTitle("My first window");
this.setLocationRelativeTo(null);
//Instanciation d'un objet JPanel
JPanel pan = new JPanel();
//On prévient notre JFrame que notre JPanel sera son ContentPane
getContentPane().add(pan) ;
//Définition de sa couleur de fond
pan.setBackground(Color.RED);
this.setVisible(true);
}
}
La classe JPanel
L’objet Jpanel
Exemple 3
import javax.swing.* ;
import java.awt.* ;
class MaFenetre extends JFrame{
public MaFenetre (){
setTitle ("Fenetre = panneau jaune") ;
setSize (300, 150) ;
pan = new JPanel() ;
pan.setBackground (Color.yellow) ;
getContentPane().add(pan) ;
}
private JPanel pan;
}
public class Paneau{
public static void main (String args[]){
MaFenetre fen = new MaFenetre() ;
fen.setVisible(true) ;
}
}
Gestion d’événement
Gestion d’un clic dans la fenêtre
Implémentation de l’interface MouseListener

Il existe une catégorie d’événements souris qu’on peut traiter avec un
écouteur de souris, c’est-à-dire un objet d’une classe implémentant
l’interface MouseListener.
Cette dernière comporte cinq méthodes correspondant chacune à un
événement particulier :
mousePressed, mouseReleased, mouseEntered, mouseExited et
mouseClicked.
class EcouteurSouris implements MouseListener{
public void mouseClicked (MouseEvent ev) { ..... }
public void mousePressed (MouseEvent ev) { ..... }
public void mouseReleased(MouseEvent ev) { ..... }
public void mouseEntered (MouseEvent ev) { ..... }
public void mouseExited (MouseEvent ev) { ..... }
Implémentation de l’interface MouseListener
Exemple 2
import javax.swing.*; import java.awt.event.*;
class MaFenetre extends JFrame implements MouseListener{
MaFenetre () {// constructeur
setTitle ("Gestion de clics") ; setBounds (10, 20, 300, 200) ;
addMouseListener (this) ; // la fenêtre sera son propre écouteur
// d’événements souris
}
public void mouseClicked(MouseEvent ev){// méthode gérant un clic souris
int x = ev.getX() ;
int y = ev.getY() ;
System.out.println ("clic au point de coordonnees " + x + ", " + y ) ;
}
public void mousePressed (MouseEvent ev) {}
public void mouseReleased(MouseEvent ev) {}
public void mouseEntered (MouseEvent ev) {}
public void mouseExited (MouseEvent ev) {}
}
public class Test{
MaFenetre fen = new MaFenetre(); fen.setVisible(true);}}
La notion d’adaptateur
Java dispose d’une classe particulière MouseAdapter qui
implémente toutes les méthodes de l’interface MouseListener avec un
corps vide. Autrement dit, tout se passe comme si MouseAdapter était
définie ainsi :
class MouseAdapter implements MouseListener{
public void mouseClicked (MouseEvent ev) {}
public void mousePressed (MouseEvent ev) {}
public void mouseReleased(MouseEvent ev) {}
public void mouseEntered (MouseEvent ev) {}
public void mouseExited (MouseEvent ev) {}
}
import java.awt.event.* ;
class MaFenetre extends JFrame {
MaFenetre (){// constructeur
setTitle ("Gestion de clics") ; setBounds (10, 20, 300, 200) ;
addMouseListener (new EcouteurSouris());
}
class EcouteurSouris extends MouseAdapter{
public void mouseClicked(MouseEvent ev) {// méthode gérant un clic souris
int x = ev.getX() ; int y = ev.getY() ;
System.out.println ("clic au point de coordonnees " + x + ", " + y ) ;
}}}
public class Test{
MaFenetre fen = new MaFenetre() ;
fen.setVisible(true) ;}}
import java.awt.event.* ;
class MaFenetre extends JFrame{
public MaFenetre (){// constructeur
setTitle ("Gestion de clics") ;
setBounds (10, 20, 300, 200) ;
addMouseListener( new MouseAdapter(){
public void mouseClicked(MouseEvent ev){
int x = ev.getX() ; int y = ev.getY() ;
System.out.println ("clic au point de coordonnées " + x + ", " + y ) ;}}
);
}}
public class Test{
MaFenetre fen = new MaFenetre() ; fen.setVisible(true) ;
}}
Gestionnaires de placement (Layout
manager)
Les gestionnaires de placement (layout manager) permettent de
disposer des composants dans un panneau en fonction des
caractéristiques qui leurs sont propres, notamment leur preferredSize.
De nombreux gestionnaires de placement sont disponibles en Swing,

et on peut évidemment programmer un gestionnaire de placement
original, si le besoin s'en fait sentir.
Le LayoutManager doit être ajouté au container, soit lors de l’appel à
son constructeur, soit par la méthode setLayout().
Tous ces layout managers se trouvent dans le package java.awt.

manager)
BorderLayout:
• Le conteneur est divisé en 5 zones : nord, sud, est, ouest, et le
centre. Il ne peut donc pas contenir plus de 5 composants.
• Les composant sont séparés horizontalement et verticalement par
des espaces, qui peuvent être modifiés par les méthodes
setHgap(int g) et setVgap(int g).
• La methode BorderLayout (int hgap,int vgap) permet de préciser
l'espacement horizontal et vertical des composants.
• La méthode add() prenant en second paramètre une des constantes
BorderLayout.NORTH, BorderLayout.SOUTH,
BorderLayout.WEST, BorderLayout.EAST ou
BorderLayout.CENTER, permet d’ajouter les composants.
manager)
import java.awt.BorderLayout;
import javax.swing.JButton;
public class Fenetre extends JFrame{
public Fenetre(){
this.setTitle("Bouton");
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLayout(new BorderLayout());
this.getContentPane().add(new JButton("CENTER"), BorderLayout.CENTER);
this.getContentPane().add(new JButton("NORTH"), BorderLayout.NORTH);
this.getContentPane().add(new JButton("SOUTH"), BorderLayout.SOUTH);
this.getContentPane().add(new JButton("WEST"), BorderLayout.WEST);
this.getContentPane().add(new JButton("EAST"), BorderLayout.EAST);
this.setVisible(true);}}
manager)
BorderLayout:
Remarque
Pour modifier par exemple la taille du composant du centre, on utilise
la méthode setPreferredSize():
button = new JButton("CENTER");

button.setPreferredSize(new Dimension(200, 100));
pane.add(button, BorderLayout.CENTER); //pane objet de ContentPane
manager)
FlowLayout
Les composants sont placés les uns à la suite des autres horizontalement,
en passant à la ligne suivante quand il n'y a plus de place sur la ligne.
Chaque composant a sa taille préférée. Le gestionnaire de placement
peut:
 centrer les composants : FlowLayout.CENTER (par défaut)
 aligner à gauche : FlowLayout.LEFT
 aligner à droite : FlowLayout.RIGHT
 leading : FlowLayout.LEADING les composants sont alignés à partir
du début du conteneur ( à gauche si le composant est orienté
ComponentOrientation.LEFT_TO_RIGHT et à droite si le composant
est orienté ComponentOrientation.RIGHT_TO_LEFT
manager)
FlowLayout
Les composant sont séparés horizontalement et verticalement

par des espaces, qui peuvent être modifiés par les méthodes
setHgap(int g) et setVgap(int g)
FlowLayout( int align): Permet de préciser l'alignement des
composants dans le conteneur (CENTER, LEFT, RIGHT ... ). Par
défaut, align vaut CENTER
FlowLayout( int align, int hgap, int vgap): Permet de préciser
l'alignement et l'espacement horizontal et vertical.
manager)
FlowLayout
import java.awt.*;
public class MaFenetre extends Frame {
JButton reveButton; JButton foiButton; JButton implicationButton;
JButton butsButton; JButton actionButton;
public MaFenetre() {
super("Cinq clés de la réussite");
setSize(348, 128); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
FlowLayout flo = new FlowLayout(); setLayout(flo);
reveButton = new JButton("LE RÊVE"); foiButton = new JButton("LA FOI");
implicationButton = new JButton("L'IMPLICATION");
butsButton = new JButton("LES BUTS"); actionButton = new
JButton("L'ACTION");
add(reveButton); add(foiButton); add(implicationButton); add(butsButton);
add(actionButton);}
public static void main(String[] args) {
MaFenetre f=new MaFenetre(); f.SetVisible();}}
manager)
GridLayout:
Les composants sont placés dans un tableau à deux dimensions
de getColumns() colonnes et getRows() lignes.
S'il y a plus de getColumns()*getRows() éléments on ajoute

autant de colonnes qu'il faut pour que getColumns()*getRows()
soit supérieur ou égal au nombres de composants du conteneur.
Les composant sont séparés horizontalement et verticalement

par des espaces, qui peuvent être modifiés par les méthodes
setHgap(int g) et setVgap(int g).
Le placement dépend de la propriété componentOrientation du

composant.
manager)
GridLayout
import java.awt.GridLayout;
import javax.swing.JButton;
public class Fenetre extends JFrame{
public Fenetre(){
this.setTitle("Bouton");
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//On définit le layout à utiliser sur le ContentPane
this.setLayout(new GridLayout(3, 2)); //Trois lignes sur deux colonnes
//On ajoute le bouton au ContentPane de la JFrame
this.getContentPane().add(new JButton("1"));
this.setVisible(true);}}
manager)
GridLayout
 Vous pouvez ajouter de l'espace entre les colonnes et les lignes en
utilisant les méthodes setHgap () et setVgap ():
GridLayout gl = new GridLayout(3, 2);

gl.setHgap(5); //Cinq pixels d'espace entre les colonnes (H comme Horizontal)
gl.setVgap(5); //Cinq pixels d'espace entre les lignes (V comme Vertical)
Ou en abrégé :
GridLayout gl = new GridLayout(3, 2, 5, 5);

manager)
GridLayout
Atelier 1: interface utilisateur d’un clavier de calculatrice
manager)
Atelier 1: interface utilisateur d’un clavier de calculatrice
Boutons
La classe JButton
import javax.swing.* ; import java.awt.* ; import java.awt.event.* ;
class Fen1Bouton extends JFrame{
public Fen1Bouton (){
setTitle ("Premier bouton") ;
setSize (300, 200) ;
monBouton = new JButton ("ESSAI") ;
setLayout(new FlowLayout()) ;
getContentPane().add(monBouton) ;
}
private JButton monBouton ;
}
public class Test{
Fen1Bouton fen = new Fen1Bouton() ;
}
}
Boutons
Gestion du bouton avec un écouteur

Il suffit simplement de savoir que l’événement qui nous intéresse est
l’unique événement d’une catégorie d’événements nommée Action. Il
faudra donc :
 créer un écouteur qui sera un objet d’une classe qui implémente
l’interface ActionListener; cette dernière ne comporte qu’une
méthode nommée actionPerformed() ;
 associer cet écouteur au bouton par la méthode addActionListener()
(présente dans tous les composants qui en ont besoin, donc en
particulier dans la classe JButton).
Boutons:Gestion du bouton avec un écouteur
import javax.swing.* ;import java.awt.* ;import java.awt.event.* ;

class Fen1Bouton extends JFrame implements ActionListener {
public Fen1Bouton (){
setTitle ("Premier bouton") ;
setSize (300, 200) ;
monBouton = new JButton ("ESSAI") ;
getContentPane().setLayout(new FlowLayout()) ;
getContentPane().add(monBouton) ;
monBouton.addActionListener(this);}
public void actionPerformed (ActionEvent ev){
System.out.println ("action sur bouton ESSAI") ;}
private JButton monBouton ;
}
public class Test{
Fen1Bouton fen = new Fen1Bouton() ;
fen.setVisible(true);}}
Gestion de plusieurs composants
La méthode getSource et getActionCommand()

 La méthode getSource() permet d’identifier la source d’un événement et
elle a le mérite de s’appliquer à tous les événements générés par tous les
composants. (présente dans toutes les classes événements, donc dans
ActionEvent)
 Il existe une autre technique d’identification d’une source d’événements
qui ne s’applique qu’aux événements de la catégorie Action. Elle se
fonde sur le fait que tout événement de cette catégorie est caractérisé par
ce que l’on nomme une chaîne de commande, i.e. une chaîne de
caractères (String) associée à l’action. Par défaut, dans le cas d’un
bouton, la chaîne de commande n’est rien d’autre que l’étiquette de ce
bouton.
 La méthode getActionCommand(), présente uniquement dans la classe
ActionEvent, permet d’obtenir la chaîne de commande associée à la
source d’un événement.
import javax.swing.*; import java.awt.* ;

import java.awt.event.*;
class Fen2Boutons extends JFrame implements ActionListener{
public Fen2Boutons (){
setTitle ("Avec deux boutons") ; setSize (300, 200) ;
monBouton1 = new JButton ("Bouton A") ;
monBouton2 = new JButton ("Bouton B") ;
Container contenu = getContentPane() ;
contenu.setLayout(new FlowLayout()) ;
contenu.add(monBouton1); contenu.add(monBouton2) ;
monBouton1.addActionListener(this); monBouton2.addActionListener(this);
}
if (ev.getSource() == monBouton1)
System.out.println ("action sur bouton numero 1") ;
if (ev.getSource() == monBouton2)
System.out.println ("action sur bouton numero 2") ;}
private JButton monBouton1, monBouton2 ;}
public class Test{
Fen2Boutons fen = new Fen2Boutons(); fen.setVisible(true);} }
import javax.swing.* ; import java.awt.* ; import java.awt.event.* ;

class Fen2Boutons extends JFrame implements ActionListener{
public Fen2Boutons (){
setTitle ("Avec deux boutons") ; setSize (300, 200) ;
monBouton1 = new JButton ("Bouton A") ; monBouton2 = new JButton ("Bouton B") ;
contenu.setLayout(new FlowLayout()) ;
contenu.add(monBouton1) ; contenu.add(monBouton2) ;
monBouton1.addActionListener(this);
monBouton2.addActionListener(this);
}
String nom = ev.getActionCommand() ;
System.out.println ("Action sur bouton " + nom) ;
}
private JButton monBouton1, monBouton2 ;
}
public class Test{
Fen2Boutons fen = new Fen2Boutons() ;
fen.setVisible(true) ;} }
Les contrôles usuels: Les cases à cocher:
JCheckBox
JCheckBox
Par défaut, une case à cocher est construite dans l’état non coché. On
peut lui imposer l’état coché en utilisant une autre version de
constructeur, comme dans :
JCheckBox coche = new JCheckBox ("CASE", true) ;
Notez que l’appel JCheckBox ("CASE") est équivalent à l’appel

JCheckBox ("CASE", false).
JCheckBox
État d’une case à cocher
On peut connaître l’état d’une case à un moment donné (indépendammen
de son éventuel changement d’état).
Il suffit pour cela de faire appel à la méthode isSelected() de la classe
JCheckBox :
if (case.isSelected()) .....
Enfin, indépendamment de l’action de l’utilisateur, on peut, à tout instant,

imposer à une case un état donné en recourant à la méthode setSelected:
case.setSelected(true) ; // coche la case de référence case, quel que

// soit son état actuel
JCheckBox
Réaction à l’action sur une case à cocher

Chaque action de l’utilisateur sur une case à cocher génère à la fois :
 un événement Action
 un événement Item
Pour réagir immédiatement à un changement d’état d’une case à
cocher, on lui associera donc un écouteur approprié, c’est-à-dire de la
catégorie Action ou de la catégorie Item.
Un écouteur de la catégorie Action doit implémenter l’interface
ActionListener
Un écouteur de la catégorie Item doit implémenter l’interface
ItemListener ; celle-ci ne comporte qu’une seule méthode,
itemStateChanged, d’en-tête :
public void itemStateChanged (ItemEvent ev)
JCheckBox
import java.awt.* ; import java.awt.event.* ; import javax.swing.* ;
class FenCoches extends JFrame implements ActionListener{
public FenCoches (){
setTitle ("Exemple de cases à cocher") ;
setSize (400, 100) ;
contenu.setLayout (new FlowLayout()) ;
coche1 = new JCheckBox ("case 1") ; contenu.add(coche1) ; coche1.addActionListener (this) ;
coche2 = new JCheckBox ("case 2") ; contenu.add(coche2) ; coche2.addActionListener (this) ;
État = new JButton ("État") ; contenu.add(État) ;État.addActionListener (this) ;}
Object source = ev.getSource() ;
if (source == coche1) System.out.println ("action case 1") ;
if (source == État)
System.out.println ("État CASES : " + coche1.isSelected() + " "+ coche2.isSelected()) ;}
private JCheckBox coche1, coche2 ; private JButton État ;}
public class Test{
FenCoches fen = new FenCoches() ;
JCheckBox
class FenCoches extends JFrame implements ActionListener, ItemListener{
public FenCoches (){
//…….
coche1 = new JCheckBox ("case 1") ; contenu.add(coche1) ;
coche1.addItemListener (this) ;
coche2 = new JCheckBox ("case 2") ; contenu.add(coche2) ;
coche2.addItemListener (this) ;
État = new JButton ("État") ; contenu.add(État) ;
État.addActionListener (this) ;}
public void itemStateChanged (ItemEvent ev){
if (source == coche2) System.out.println ("action case 2") ;}
public void actionPerformed (ActionEvent ev) {
System.out.println ("État CASES : " + coche1.isSelected() + " "+
coche2.isSelected()) ;}
//…..
Les contrôles usuels: Les boutons radio:
JRadioButton
JRadioButton
class FenCoches extends JFrame implements ActionListener{
public FenCoches (){ //……
ButtonGroup groupe = new ButtonGroup() ;
radio1 = new JRadioButton ("Radio 1",
true);groupe.add(radio1);contenu.add(radio1);radio1.addActionListener(this);
radio2 = new JRadioButton ("Radio 2") ; groupe.add(radio2); contenu.add(radio2) ;
radio2.addActionListener(this);
radio3 = new JRadioButton ("Radio 3") ; groupe.add(radio3); contenu.add(radio3) ;
radio3.addActionListener(this);
État = new JButton ("État"); contenu.add(État) ;
État.addActionListener (this) ;}
if (source == radio1) System.out.println ("action radio 1") ;
if (source == État) System.out.println ("État RADIOS : " + radio1.isSelected() + " “
+ radio2.isSelected() + " " + radio3.isSelected()); }
private JRadioButton radio1, radio2, radio3; private JButton État ;}
JRadioButton
class FenCoches extends JFrame implements ActionListener, ItemListener{
FenCoches (){ setTitle ("Exemple de boutons radio") ; setSize (400, 100) ;
Container contenu = getContentPane();
contenu.setLayout (new FlowLayout());
ButtonGroup groupe = new ButtonGroup() ;
radio1 = new JRadioButton ("Radio 1");
groupe.add(radio1); contenu.add(radio1); radio1.addItemListener (this) ;
radio1.addActionListener(this); radio1.setSelected (true) ; radio2 = new JRadioButton ("Radio 2") ; groupe.add(radio2);
contenu.add(radio2); radio2.addItemListener(this); radio2.addActionListener(this) ;
radio3 = new JRadioButton("Radio 3") ; groupe.add(radio3); contenu.add(radio3) ;
radio3.addItemListener(this); radio3.addActionListener(this) ;
État = new JButton ("État") ; contenu.add(État); État.addActionListener (this) ;}
public void itemStateChanged(ItemEvent ev){ Object source = ev.getSource() ;
if (source == radio1) System.out.println ("changement radio 1") ;
if (source == radio2) System.out.println ("changement radio 2") ;
if (source == radio3) System.out.println ("changement radio 3") ;}
public void actionPerformed (ActionEvent ev){ Object source = ev.getSource() ;
if (source == État) System.out.println ("État RADIOS : " + radio1.isSelected() + " "
+ radio2.isSelected() + " " + radio3.isSelected()) ;
if (source == radio3) System.out.println ("action radio 3") ;}
private JRadioButton radio1, radio2, radio3; private JButton État ;}
public class Test{ public static void main (String args[]){FenCoches fen = new FenCoches() ; fen.setVisible(true);}}
Les contrôles usuels: Les étiquettes JLabel
Un composant de type JLabel permet d’afficher dans un conteneur

un texte (d’une seule ligne) non modifiable par l’utilisateur, mais
que le programme peut faire évoluer.
Le constructeur de JLabel précise le texte initial :

JLabel texte = new JLabel ("Texte initial") ;
Le programme peut modifier à tout instant le texte d’une étiquette à

l’aide de la méthode setText, par exemple :
texte.setText ("nouveau texte") ;
Les contrôles usuels: Les étiquettes JLabel
import java.awt.*; import java.awt.event.*; import javax.swing.* ;

class FenLabel extends JFrame implements ActionListener{
public FenLabel (){
setTitle ("Essais Etiquettes"); setSize (300, 120) ;
contenu.setLayout (new FlowLayout() ) ;
bouton = new JButton ("Compteur") ;
bouton.addActionListener(this) ;
contenu.add(bouton) ;
nbClics = 0 ;
compte = new JLabel ("Nombre de clics sur Compteur = "+ nbClics) ; contenu.add(compte);}
public void actionPerformed (ActionEvent e){
nbClics++ ;
compte.setText("nombre de clics sur Compteur = "+nbClics) ;}
private JButton bouton ; private JLabel compte ; private int nbClics ;}
public class Test{
FenLabel fen = new FenLabel() ;
fen.setVisible(true);}
}
Les contrôles usuels: JTextField
• Un champ de texte (on dit aussi une boîte de saisie) est une zone
rectangulaire (avec bordure) dans laquelle l’utilisateur peut entrer ou
modifier un texte (d’une seule ligne). Il s’obtient en instanciant un
objet de type JTextField.
• Exemples de constructions de champs de texte dans un objet de type
JFrame :
• JTextField texte1, texte2 ;
• texte1 = new JTextField (20) ; // champ de taille 20, initialement vide
• texte2 = new JTextField ("texte initial", 15) ; // champ de taille 15
// contenant au départ le texte :texte initial
• On peut connaître à tout moment l’information figurant dans un
champ de texte en utilisant la méthode getText(), par exemple :
• String ch = texte1.getText() ;
Remarque
Lors de l’exécution on peut modifier la taille d’un champ de texte
avec la méthode setColumns().
Pour que la modification soit immédiatement prise en compte par le
layout Manager, il est nécessaire de lui appliquer la méthode
revalidate() (ou encore d’appliquer la méthode validate() à son
conteneur) :
texte1.setComumns (30) ; // on donne à texte1 une largeur de 30
texte1.revalidate() ; // ou encore, si le conteneur est de type JFrame :
// getContententPane().validate() ;

class FenText extends JFrame implements ActionListener{
public FenText (){
setTitle ("Saisie de texte") ; setSize (300, 120) ;
saisie = new JTextField (20) ; contenu.add(saisie);
saisie.addActionListener(this) ;
bouton = new JButton ("COPIER") ; contenu.add(bouton);
bouton.addActionListener(this) ;
copie = new JTextField (20) ; copie.setEditable(false); contenu.add(copie);}
if (e.getSource() == bouton){
String texte = saisie.getText() ;
copie.setText(texte);}}
private JTextField saisie, copie ; private JButton bouton ;}
public class Test{ public static void main (String args[]){
FenText fen = new FenText() ; fen.setVisible(true);}}

class FenText extends JFrame implements ActionListener, FocusListener{
public FenText (){
setTitle ("Saisie de texte"); setSize (300, 100) ;
saisie = new JTextField (20) ;
contenu.add(saisie); saisie.addActionListener(this); saisie.addFocusListener(this) ;
copie = new JTextField (20) ; copie.setEditable(false); contenu.add(copie);}
System.out.println ("validation saisie") ;
String texte = saisie.getText(); copie.setText(texte);}
public void focusLost (FocusEvent e){
System.out.println ("perte focus saisie") ;
String texte = saisie.getText(); copie.setText(texte);}
public void focusGained (FocusEvent e){
System.out.println ("focus sur saisie") ;}
private JTextField saisie, copie ; private JButton bouton ;}
public class Test{
FenText fen = new FenText() ; fen.setVisible(true);}}
Les contrôles usuels : JTextArea
Une zone de texte multiligne s’obtient en instanciant un objet de

type JTextArea.
Les instructions suivantes créent et ajoutent un composant
JTextArea avec 40 caractères et 8 lignes à un container:
JTextArea commentaires = new JTextArea(8, 40);

FlowLayout flo = new FlowLayout();
setLayout(flo);
add(commentaires);
Les boîtes de liste : Jlist
 On crée une boîte de liste en fournissant un tableau de chaînes à son

constructeur, par exemple :
String[] couleurs = {"rouge", "bleu", "gris", "vert", "jaune", "noir" } ;

JList liste = new JList (couleurs) ;
 On peut forcer la sélection d’un élément de rang donné par la

méthode setSelectedIndex():
liste.setSelectedIndex (2); // sélection préalable de l’élément de rang 2

import java.awt.* ; import javax.swing.* ;

class FenText extends JFrame{
public FenText (){
setTitle ("Exemple JList") ;
setSize (300, 110) ;
liste.setSelectedIndex (4);
contenu.add(liste);
}}
public class Test{
FenText fen = new FenText() ;
Les différents types de boîtes de liste
Par défaut, on a affaire à une boîte de type

MULTIPLE_INTERVAL_SELECTION.
Pour modifier le type de boîte de liste, on utilise la :
void setSelectionMode (int modeDeSelection)
Exemple : liste.setSelectionMode (SINGLE_SELECTION) ; // liste sera
à
//sélection simple
Les boîtes de liste: Panneau de défilement:
JScrollPane
JScrollPane defil = new JScrollPane (liste) ; // introduit la liste
// dans un panneau de défilement
Il faudra alors prendre soin d’ajouter (par add) au conteneur concerné
non plus la liste elle-même, mais le panneau de défilement ; par
exemple, pour un conteneur de type JFrame :
getContentPane().add(defil) ; // ajoute le panneau au contenu de la fenêtre
On peut modifier ce nombre par la méthode setVisibleRowCount():
liste.setVisibleRowCount(3) ; // seules 3 valeurs seront visibles a la fois

Les boîtes de liste: Panneau de défilement:
JScrollPane
import java.awt.*; import javax.swing.*;
class FenText extends JFrame{
public FenText (){
setTitle ("Exemple JScrollPane");
setSize (300, 110);
String[] couleurs = {"rouge", "bleu", "gris", "vert", "jaune", "noir", "red", "blue",
"gray", "green", "yellow", "black"} ;
JScrollPane defil = new JScrollPane (liste);
contenu.add(defil);}}
public class Test{
FenText fen = new FenText() ;
}}
Les boîtes de liste
Accès aux informations sélectionnées

• Pour une liste à sélection simple, la méthode getSelectedValue()
fournit la (seule) chaîne sélectionnée.
• On notera que son résultat est de type Object et non String; il faudra
donc procéder à une conversion explicite, comme dans :
String ch = (String) liste.getSelectedValue() ; // cast obligatoire ici
• Pour la séléction multiples pourobtenir toutes les valeurs, on utilisera

la méthode getSelectedValues() qui fournit un tableau d’objets.
Object[] valeurs = liste.getSelectedValues() ;
for (int i = 0 ; i<valeurs.length ; i++)
System.out.println ((String) valeurs[i]) ;
Les boîtes combo
Construction d’une boîte combo

On pourra construire la boîte combo de cette façon :
JComboBox combo = new JComboBox(couleurs) ;
Pour rendre une boîte combo éditable, on utilisera la méthode
setEditable, par exemple :
combo.setEditable(true) ; // la boite de texte associée est éditable
On peut modifier le nombre de valeurs visibles par la méthode
setMaximumRowCount :
combo.setMaximumRowCount (4) ; // au maximum 4 valeurs affichées
Comme pour une boîte de liste, on peut forcer la sélection d’un élément
de rang donné par setSelectedIndex():
combo.setSelectedIndex (2) ; // sélection préalable de l’élément de rang 2
Les boîtes combo
Accès à l’information sélectionnée ou saisie

La méthode getSelectedItem() fournit la valeur sélectionnée, qu’il
s’agisse d’une valeur provenant de la liste prédéfinie ou d’une valeur
saisie dans le champ texte associé.
Comme la méthode setSelectedValue() des boîtes de liste, elle fournit un

résultat de type Object qu’il faudra souvent convertir en chaîne :
Object valeur = combo.getSelectedItem() ;
La méthode getSelectedIndex() fournit aussi le rang de la valeur

sélectionnée.
Les boîtes combo
Évolution dynamique de la liste d’une boîte combo

Il n’est pas aisé de faire évoluer le contenu d’une boîte de liste (JList).
La boîte combo dispose quant à elle de méthodes appropriées à sa
modification.
La méthode addItem() permet d’ajouter une nouvelle valeur à la fin de
la liste :
combo.addItem ("orange") ; // ajoute orange en fin de la liste combo
La méthode insertItemAt permet d’insérer une nouvelle valeur à un
rang donné :
combo.insertItemAt ("rose", 2) ; // ajoute rose en position 2
La méthode removeItem permet de supprimer une valeur existante :
combo.removeItem ("gris") ; // supprime orange de la liste combo
Les contrôles usuels : Les Menus
Les contrôles usuels : Les Menus
Contrôleurs d’évènements (listeners)
• Les « listeners » sont des interfaces. Ces interfaces fournissent une ou

plusieurs méthodes qui peuvent donc être implémentées différemment
selon les cas et les besoins, pour répondre aux événements(clic de
souris, touche du clavier enfoncée, etc.).
• Les interfaces « listener » sont présentes principalement dans le
package java.awt.event, mais également dans le package
javax.swing.event.
• Chaque listener dispose d'une classe Event associée. Cette classe

étend java.awt.event.EventObject et fournit une description de
l'évènement capturé. Par exemple, la classe ActionEvent décrit les
évènements capturés par un ActionListener.
Comment utiliser les listeners
1ère possibilité : implémentation de l'interface dans la classe principale.
KeyListener
159
Il est utilisé pour réagir aux évènements du clavier, et est donc

utilisable sur des composants permettant la saisi de texte
(JTextField, JTextArea, etc.).
Trois méthodes sont déclarées dans l'interface du KeyListener :

keyTyped(KeyEvent e), keyPressed(KeyEvent e) et
keyReleased(KeyEvent e).
Elle permettent respectivement de réagir lorsqu'une touche a été :
tapé (pressé puis relâché), pressé, relâché.
La classe KeyEvent étend java.util.EventObject et dispose donc des

méthodes déclarées dans cette classe (notamment getSource()).
KeyListener
La classe KeyEvent fournit également une dizaine d'autres méthodes

spécifiques aux évènements relatifs au clavier, comme:
getKeyChar() retourne le caractère associé à la touche appuyée,
getKeyCode() récupère le code de la touche pressée,
isActionKey() retourne true si la touche appuyée est une touche
d'action (CAPS LOCK, Verr Num, etc.),
getKeyText(int keyCode) retourne le texte associée à la touche
(par ex. F1, A, etc.).
MouseListener :
La classe MouseEvent étend java.util.EventObject et dispose donc

des méthodes déclarées dans cette classe (notamment getSource()).
Elle fournit également 12 autres méthodes spécifiques aux
événements relatifs à la souris, comme:
getButton() retourne le bouton qui a été cliqué,
getClickCount() retourne le nombre de clics (utile pour gérer le
double clic),
getLocationOnScreen() retourne un objet Point représentant la
position de la souris à l'écran,
isPopupTrigger() précise si le bouton cliqué est celui
habituellement utilisé pour afficher la liste déroulante (bouton
droit sur le bureau Windows par exemple).
FocusListener
• Il est utilisé pour les événements relatifs au focus clavier.

Cette interface déclare 2 méthodes :
focusGained(FocusEvent e) indique que le composant a gagné le focus
clavier.
focusLost(FocusEvent e) indique que le composant a perdu le focus
clavier.
• La classe FocusEvent étend java.util.EventObject et dispose donc des
méthodes déclarées dans cette classe (notamment getSource()).
Elle fournit également 3 autres méthodes spécifiques aux événements relatifs
aux fenêtres, comme:
isTemporary() indique si le composant n’a le focus que temporairement.
getOppositeComponent() retourne l'autre composant impliqué dans le
changement de focus.
Afin d'ajouter un FocusListener, vous disposez de la méthode

Mme Khadija Bouzaachane

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Mme Khadija Bouzaachane

Transféré par

Droits d'auteur :

Formats disponibles

IHM

Mme Khadija Bouzaachane

Rôles d’une interface utilisateur:

Le schéma Modèle-Vue-Contrôleur (MVC) est un mode de

La décomposition MVC du bouton ci-dessous (instance de la

 Du modèle contenant la chaîne de caractères “Quitter” ;

Tous les composants graphiques du package SWING ont un modèle,

Pour faciliter la programmation, certaines classes (tel que JButton)

Une fenêtre peut donc être construite selon le principe suivant :

 En plus des caractéristiques d’un composant simple, un container

Composer une fenêtre

JPanel p = new JPanel();

Action sur les caractéristiques d’une fenêtre

Action sur les caractéristiques d’une fenêtre

Action sur les caractéristiques d’une fenêtre

Action sur les caractéristiques d’une fenêtre

Implémentation de l’interface MouseListener

De nombreux gestionnaires de placement sont disponibles en Swing,

Tous ces layout managers se trouvent dans le package java.awt.

button = new JButton("CENTER");

Les composant sont séparés horizontalement et verticalement

S'il y a plus de getColumns()*getRows() éléments on ajoute

Les composant sont séparés horizontalement et verticalement

Le placement dépend de la propriété componentOrientation du

GridLayout gl = new GridLayout(3, 2);

GridLayout gl = new GridLayout(3, 2, 5, 5);

Gestion du bouton avec un écouteur

import javax.swing.* ;import java.awt.* ;import java.awt.event.* ;

La méthode getSource et getActionCommand()

import javax.swing.*; import java.awt.* ;

import javax.swing.* ; import java.awt.* ; import java.awt.event.* ;

JCheckBox coche = new JCheckBox ("CASE", true) ;

Notez que l’appel JCheckBox ("CASE") est équivalent à l’appel

Enfin, indépendamment de l’action de l’utilisateur, on peut, à tout instant,

case.setSelected(true) ; // coche la case de référence case, quel que

Réaction à l’action sur une case à cocher

Un composant de type JLabel permet d’afficher dans un conteneur

Le constructeur de JLabel précise le texte initial :

Le programme peut modifier à tout instant le texte d’une étiquette à

import java.awt.*; import java.awt.event.*; import javax.swing.* ;

import java.awt.* ; import java.awt.event.* ; import javax.swing.* ;

import java.awt.* ; import java.awt.event.* ; import javax.swing.* ;

Une zone de texte multiligne s’obtient en instanciant un objet de

JTextArea commentaires = new JTextArea(8, 40);

 On crée une boîte de liste en fournissant un tableau de chaînes à son

String[] couleurs = {"rouge", "bleu", "gris", "vert", "jaune", "noir" } ;

 On peut forcer la sélection d’un élément de rang donné par la

liste.setSelectedIndex (2); // sélection préalable de l’élément de rang 2

import java.awt.* ; import javax.swing.* ;

Par défaut, on a affaire à une boîte de type

On peut modifier ce nombre par la méthode setVisibleRowCount():

liste.setVisibleRowCount(3) ; // seules 3 valeurs seront visibles a la fois

Accès aux informations sélectionnées

String ch = (String) liste.getSelectedValue() ; // cast obligatoire ici

• Pour la séléction multiples pourobtenir toutes les valeurs, on utilisera

Construction d’une boîte combo

Accès à l’information sélectionnée ou saisie

Comme la méthode setSelectedValue() des boîtes de liste, elle fournit un

Object valeur = combo.getSelectedItem() ;

La méthode getSelectedIndex() fournit aussi le rang de la valeur

Évolution dynamique de la liste d’une boîte combo

• Les « listeners » sont des interfaces. Ces interfaces fournissent une ou

• Chaque listener dispose d'une classe Event associée. Cette classe

import javax.swing.; import java.awt. ;

import java.awt.; import java.awt.event.; import javax.swing.* ;