Cours Java SWING

Java Swing & les interfaces
Homme-Machine (IHM)
Les interfaces homme-machine et le langage Java
1. Introduction
-L'interface homme-machine,
- interaction humain-machine (IHM),
- intégration hommes système (IHS) ou
- interface personne-machine (IPM)
 Définit, les moyens et outils mis en œuvre, afin qu'un humain puisse contrôler et
communiquer avec une machine.
 Les ingénieurs en ce domaine cherche à concevoir des systèmes qui soient:
• Ergonomiques,
• Efficaces,
• Faciles à utiliser ou
• plus généralement adaptés à leur contexte d'utilisation. 2
1. Introduction
D'un point de vue organique, on peut distinguer trois types d'IHM:
 Les interfaces d'acquisition:
- Boutons - Clavier - Joysticks

- Télécommande - Capteur du mouvement - Microphone avec la
reconnaissance vocale, …
 Les interfaces de restitution:
- Écrans,
- Témoins à LED,
- Haut parleur, …
 Les interfaces combinées:

- Écrans tactiles,
- Multi-touches,
- Manette interactive (Kinect de la XBox, PlayStation Move de la PlayStation), …
Chapitre 1: Les interfaces homme-machine et le langage Java 3.

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.
Chapitre 1: Les interfaces homme-machine et le langage Java

4.
2. 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.
Exemple

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), …
 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), ..

La gestion de l’arbre d’affichage

Exemple d’une hiérarchie
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 ");
GridLayout layoutPanneauBleu = new GridLayout(2,1);

layoutPanneauBleu. setVgap(3);
PanneauBleu.setLayout(PanneauBleu);
conteneur1.add(PanneauBleu);
conteneur1.add(composant3);
PanneauBleu.add(composant1);
PanneauBleu.add(composant2); Chapitre 1: Les interfaces homme-machine et le langage Java 8.
2. Structure générale de Swing: Le composant JComponent
Tous les objets (conteneurs et composants) héritent de la même classe :
javax.swing.Jcomponent.
Exemples:
void setVisible ( boolean b) Montrer et cacher un composant

void setEnabled ( boolean b) Activer et désactiver un composant
boolean isEnabled () Connaître l’état (activé ou non) d’un composant
void setBackground ( Color c) Modifier la couleur de fond d’un composant
void setForeground ( Color c) Modifier la couleur du premier plan d’un composant
void setSize ( int largeur , Modifier la taille d’un composant
int hauteur )
void setBounds ( int x, int y, Modifier la position et la taille d’un composant
int largeur , int hauteur )

3. Les conteneurs de premier niveau (Top-Level Containers)
 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.

3. Les conteneurs de premier niveau (Top-Level Containers)
Exemple 1: JFrame
Jframe fenetre= new JFrame ("Example de fenêtre");
► On crée une nouvelle instance de notre Jframe
fenetre.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
► la fenêtre doit se fermer quand on clique sur la croix rouge
fenetre.getContentPane().add(new JLabel(" Bonjour !"));
► on ajoute le texte « Bonjour!" dans la fenêtre
Exemple 2: JDialog
JDialog fenetre = new JDialog();
► On crée une nouvelle instance de notre JDialog
fenetre.setTitle(”Première fenêtre Swing”);
► On lui donne un titre
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
► On dit à l'application de se fermer lors du clic sur la croix
Exemple 3: JWindow
JWindow fenetre = new JWindow();
► On crée une nouvelle instance de notre JWindow
fenetre.setSize(200, 300);
► On lui donne une taille pour qu'on puisse la voir
fenetre.setVisible(true);
► On la rend visible
3.1 Les conteneurs de premier niveau : 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.setVisible ( true );
}
}

3.1 Les conteneurs de premier niveau : 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

3.1 Les conteneurs de premier niveau : Fermeture d’une JFrame
Exemple: Création d’une fenêtre « ma fenetre » avec le bouton de fermeture inactif.
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);
}
}

3.1 Les conteneurs de premier niveau : 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()

3.1 Les conteneurs de premier niveau : Les classe toolkit
Exemple: Création d’une fenêtre centrée dans l’écran de l’ordinateur.
import java.awt.*;
public class TestJFrame5 {
JFrame fenetre = new JFrame("ma fenetre");

Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
fenetre.setLocation(dim.width/2 - fenetre.getWidth()/2,
dim.height/2 - fenetre.getHeight()/2);
}
}

3.2 Les conteneurs de premier niveau : 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.

Quelques constructeurs de JDialog
Construit une boîte de dialogue dépendant de owner, non

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

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

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é
void
Positionne la possibilité de redimensionner.
setResizable(boolean resizable)
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. v peut avoir les valeurs
void suivantes :
setDefaultCloseOperation(int v) • DO_NOTHING_ON_CLOSE : ne rien faire
• HIDE_ON_CLOSE : la fenêtre devient invisible

• DISPOSE_ON_CLOSE :la fenêtre est détruite

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

Dialogue d’information
Exemple :
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);
}
}

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);
 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

Dialogue de confirmation
Exemple :
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);
}
}

4 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, ..

4 Les conteneurs intermédiaires
Quelques méthodes :
void setLayout(LayoutManager) associe au Conteneur l’objet de 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 add(Component,Object) ajoute ce composant au Conteneur 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)
void remove(Component) enlève ce composant du Conteneur
void removeAll() enlève tous les composants du Conteneur
Component locate(int,int) retourne le composant situé aux coordonnées
données en paramètre
Void setBackground(Color.C) permet de modifier la couleur C.

4 Les conteneurs intermédiaires: 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

4 Les conteneurs intermédiaires: JPanel
Exemple: Une fenêtre JFrame avec un panneau vert qui contient le texte « Bonjour à tous! ».
import java.awt.Color;
public class TestJPanel
{
public static void main(String args [])
{
JFrame fenetre = new JFrame("Une fenetre JFrame avec panneau");
JPanel Panneau = new JPanel();
fenetre.getContentPane().add(Panneau);
Panneau.setBackground(Color.green ) ;
JLabel label = new JLabel("Bonjour à tous!");
Panneau.add(label );
}
}

5 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, …

5 Les composants atomiques: 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é

5 Les composants atomiques: 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
Exemple:
JButton bouton = new JButton("Bouton 1"); // On crée une nouvelle instance de

notre JButton
Panneau.add(bouton); //on ajoute le bouton au panneau

Une fenêtre avec deux boutons.
{
{
JFrame fenetre = new JFrame( "Une fenetre JFrame avec panneau" );

fenetre.getContentPane().add(Panneau );
JButton bouton1 = new JButton("Bouton 1");
Panneau.add(bouton1);
JButton bouton2 = new JButton("Bouton 2");
Panneau.add(bouton2);
}
}

Exercice: 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);

Solution:
import java.awt.GridLayout;
{
{String[] buttons = {"C“, "Bck", "", "close","7","8","9", "/", "4",
"5", "6", "*", "1", "2", "3", "-", "0", ".", "=", "+"};
JFrame fenetre = new JFrame( "Calculatrice" );

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]));
}
}
5 Les composants atomiques: 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, Icon,
précise l'intitulé, une icône et l'état
boolean)
Exemple:
JCheckBox bouton1 = new JCheckBox("Bouton 1"); // On crée une nouvelle

instance de notre JButton
Panneau.add(bouton1); //on ajoute le bouton à coucher au panneau

5 Les composants atomiques: JCheckBox
Exercice: Créer une fenêtre avec un panneau et deux cases à cocher de type JCheckBox.
public class TestJCheckBox {
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);
}
} Chapitre 1: Les interfaces homme-machine et le langage Java 35.
5 Les composants atomiques: JRadioButton
 Le bouton radio de type JRadioButton permet à l’utilisateur d’effectuer un choix de type

oui/non.
JPanel panneau= new JPanel();
JRadioButton bouton1 = new JRadioButton("Bouton 1"); // On crée une
nouvelle instance de notre JRadioButton
panneau.add(bouton1); //on ajoute le bouton au panneau
 Un groupe de boutons radio est encapsulé dans un objet de type ButtonGroup.
 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);

 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 :
Constructeur Rôle
JRadioButton() Créer un bouton non sélectionné sans libellé
Créer un bouton non sélectionné sans libellé avec l'icône fournie en
JRadioButton(Icon)
paramètre
JRadioButton(Icon, Créer un bouton sans libellé avec l'icône et l'état fournis en
boolean) paramètres
JRadioButton(String) Créer un bouton non sélectionné avec le libellé fourni en paramètre
JRadioButton(String,
boolean)
Créer un bouton avec le libellé et l'état fournis en paramètres
JRadioButton(String, Créer un bouton non sélectionné avec le libellé et l'icône fournis en
Icon) paramètres
JRadioButton(String,
Icon, boolean)
Créer un bouton avec le libellé, l'icône et l'état fournis en paramètres

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.
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");
group.add(radio1); panel.add(radio1);
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(); }

public static void main(String args[]) {
TestJRadioButton app = new TestJRadioButton();
app.config(); }
5 Les composants atomiques: 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
setComponentOrientation( composant : ComponentOrientation.LEFT_TO_RI
int o) GHT ou ComponentOrientation.RIGHT_TO_LEFT
void
Affecte l'alignement horizontal
setHorizontalAlignment(i
( JTextField.LEFT ou JTextField.RIGHT)
nt a)
Affecte le nombre de colonnes, qui est utilisé pour
void setColumns(int nc)
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
qui la crée avec un contenu initial et définit le nombre
JTextField(String,int)
de colonnes
void pour associer l’objet qui traitera les modifications du
addActionListener(Action texte
Listener)
 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:");

Exercice: Écrire un programme qui permet à l’utilisateur de saisir des caractères dans un champ
texte.
import java.awt.FlowLayout;
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:" );
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();
}
5 Les composants atomiques: 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 :
Constructeur Rôle
JList() Crée un JList vide.
JList(Object [] donnees)
Crée un JList qui affiche les données contenues dans le
tableau donnees.
JList(Vector v)
Crée un JList qui affiche les données contenues dans le
vecteur v.
JList (ListModel l)
Crée un JList qui affiche les données contenues dans
le ListModel l.
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é.
void setSelectedIndices(int [] i) Affecte les indices des items sélectionnés.
Object getSelectedValue() Retourne la valeur de l'item sélectionné.
Object[] getSelectedValues() Retourne un tableau des items sélectionnés.
Retourne le modèle de données affiché par
ListModel getModel()
le JList.
Le nouveau modèle de données affiché par
void setModel(ListModel lm)
le JList est lm.
ListCellRenderer getCellRenderer() Retourne l'objet qui gère le rendu des items.

Exemple:
String choix [] = {“choix1”, “choix 2”, “choix 3”}; // Liste de données à

afficher
JList liste = new JList(choix); // On crée une nouvelle instance de notre JList
avec des entrées.

Exercice: Créer une fenêtre avec un panneau et la liste des choix suivante.
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");
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);
}
5 Les composants atomiques: 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
₋ 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

Exemple:
JMenuBar BarreDeMenus=new JMenuBar(); // On crée une nouvelle instance de notre
JMenuBar
JMenu menu = new JMenu("Menu"); // On crée une nouvelle instance de notre
JMenu
BarreDeMenus.add(menu);// On ajoute JMenu à la JMenuBar
JMenuItem menuItem1 = new JMenuItem("New"); // On crée une nouvelle instance

de notre JMenuItem
Menu1.add(menuItem1); // On ajoute un sous-menu
setJMenuBar(BarreDeMenus); // On place la barre de menus dans la fenêtre.

Exercice d’application: Créer la fenêtre suivante.
public class CreationDunBarreDeMenus {
public static void main(final String
args[]) {
JFrame fenetre = new
JFrame("Exemple d'une barre de JMenuItem menuItem3 = new
Menus"); JMenuItem("Enregistrer");
fenetre.setSize(350, 250); Menu1.add(menuItem3);
JMenuItem menuItem4 = new
fenetre.getContentPane().setBackground JMenuItem("Quitter");
(Color.WHITE); Menu1.add(menuItem4);
JMenuBar BarreDeMenus = new JMenu Menu2 = new
JMenuBar(); JMenu("Edition");
JMenu Menu1 = new BarreDeMenus.add(Menu1);
JMenu("Fichier"); JMenu Menu3 = new JMenu("Aide ?");
BarreDeMenus.add(Menu1); BarreDeMenus.add(Menu1);
JMenuItem menuItem1 = new BarreDeMenus.add(Menu2);
JMenuItem("Nouveau"); BarreDeMenus.add(Menu3);
Menu1.add(menuItem1); fenetre.setJMenuBar(BarreDeMenus);
JMenuItem menuItem2 = new fenetre.setVisible(true);
JMenuItem("Ouvrir"); }
Menu1.add(menuItem2); }

Chapitre 2: 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.
 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.
50
1 Layout manager : 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 :
Constructeur Rôle
FlowLayout( );
Permet de préciser l'alignement des composants dans le
FlowLayout( int align); conteneur (CENTER, LEFT, RIGHT ... ). Par défaut, align vaut
CENTER
FlowLayout( int align, Permet de préciser l'alignement et l'espacement horizontal et
int hgap, int vgap); vertical dont la valeur par défaut est 5.
Exemple:
JFrame fenetre = new JFrame(« Ma fenêtre");
fenetre.getContentPane().setLayout(new FlowLayout(FlowLayout.CENTER));
Chapitre 2: Le positionnement des composants. 51.

1 Layout manager : 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.
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"));
setVisible(true);
}
new TestFlowLayout();
}
}

2 Layout manager : 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.
Constructeur Rôle
BorderLayout( )
BorderLayout (int hgap,int Permet de préciser l'espacement horizontal
vgap) et vertical des composants.
Exemple:
setLayout(new BorderLayout());
add("North", new Button(" bouton haut "));

2 Layout manager : BorderLayout
Exercice d’application: Créer la fenêtre suivante.
import java.awt.*;
public class TestBorderLayout extends JFrame {
public TestBorderLayout() {
super();
setTitle("Test BorderLayout");
setSize(300, 200);
setLayout(new BorderLayout());
add("North", new Button(" bouton haut "));
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);
}
new TestBorderLayout();
}
}
3 Layout manager : 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.
Constructeur Rôle
Les deux premiers entiers spécifient le nombre de
GridLayout( int, int );
lignes ou de colonnes de la grille.
GridLayout( int, int, int, permet de préciser en plus l'espacement horizontal
int ); et vertical des composants.
Exemple:
setLayout(new GridLayout(1,2));
add(new Button("bouton 1"));

 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.
Constructeur Rôle
Les deux premiers entiers spécifient le nombre de
GridLayout( int, int );
lignes ou de colonnes de la grille.
GridLayout( int, int, int, permet de préciser en plus l'espacement horizontal
int ); et vertical des composants.
Exemple:
setLayout(new GridLayout(1,2));

Exercice d’application: Créer la fenêtre suivante en utilisant le gestionnaire 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 5 tres long"));
setVisible(true);
}
new TestGridLayout();
}
}

Chapitre 3: Gestion des Evénements
1 Introduction
 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.
 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
58
1 Introduction
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.
Chapitre 3: Gestion des Evénements 59

1 Introduction
Les événements de bas niveau

2 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 {
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);
₋ 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.

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
};
 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.
Exemple:
Button b = new Button(" bouton ");
...
void public actionPerformed(actionEvent e) {
Object scan = e.getSource();
if (scan== b)
// action a effectuer
}

Exercice d’application: Créer une interface graphique qui permet de lire des caractères à partir
d’un clavier (JButton) et de les afficher dans un champ texte (JTextField).

Cours Java SWING

Transféré par

Informations du document

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

Cours Java SWING

Transféré par

Droits d'auteur :

Formats disponibles

Java Swing & les interfaces

D'un point de vue organique, on peut distinguer trois types d'IHM:

 Les interfaces d'acquisition:

- Boutons - Clavier - Joysticks

 Les interfaces combinées:

Chapitre 1: Les interfaces homme-machine et le langage Java 3.

AWT (Abstract Windowing Toolkit)

Chapitre 1: Les interfaces homme-machine et le langage Java

Chapitre 1: Les interfaces homme-machine et le langage Java 5.

Chapitre 1: Les interfaces homme-machine et le langage Java 6.

La gestion de l’arbre d’affichage

Chapitre 1: Les interfaces homme-machine et le langage Java 7.

JPanel PanneauBleu = new JPanel();

JTextField composant1= new JTextField("Champs de texte");

GridLayout layoutPanneauBleu = new GridLayout(2,1);

void setVisible ( boolean b) Montrer et cacher un composant

Chapitre 1: Les interfaces homme-machine et le langage Java 9.

 Ils constituent toujours les objets de base d'une interface Swing.

Chapitre 1: Les interfaces homme-machine et le langage Java 10.

public static void main ( String args []){

JFrame fenetre = new JFrame (" Titre de la Fenetre ");

Chapitre 1: Les interfaces homme-machine et le langage Java 12.

 Il est possible de préciser comment Jframe réagit à sa fermeture grâce à la méthode

Chapitre 1: Les interfaces homme-machine et le langage Java 13.

Exemple: Création d’une fenêtre « ma fenetre » avec le bouton de fermeture inactif.

Chapitre 1: Les interfaces homme-machine et le langage Java 14.

 Cette librairie utilise le système graphique de la plate-forme d'exécution (Windows, MacOS,

 On obtient une instance de Toolkit par la méthode de classe de Toolkit :

Chapitre 1: Les interfaces homme-machine et le langage Java 15.

Exemple: Création d’une fenêtre centrée dans l’écran de l’ordinateur.

public static void main(String argv[]) {

JFrame fenetre = new JFrame("ma fenetre");

Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();

Chapitre 1: Les interfaces homme-machine et le langage Java 16.

 Un dialogue peut être :

 Java propose un certain nombre de boîtes de dialogue standard obtenues à l’aide de

 La classe JDialog permet de construire des boîtes de dialogue personnalisées.

Chapitre 1: Les interfaces homme-machine et le langage Java 17.

Construit une boîte de dialogue dépendant de owner, non

Construit une boîte de dialogue dépendant de owner et non

Chapitre 1: Les interfaces homme-machine et le langage Java 18.

Quelques méthodes de JDialog

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

• HIDE_ON_CLOSE : la fenêtre devient invisible

Chapitre 1: Les interfaces homme-machine et le langage Java 19.

 La classeJOptionPane fournit des façon simples de créer des dialogues

 L’appel de la méthode showMessageDialog de la classeJOptionPane permet de faire

 Le type de message est l’une des valeurs suivantes :

Chapitre 1: Les interfaces homme-machine et le langage Java 20.

public class BoiteMessage {

Chapitre 1: Les interfaces homme-machine et le langage Java 21.

 L’appel de la méthode showConfirmDialog de la classeJOptionPane permet de faire

 L’option de message est l’une des valeurs suivantes :

Chapitre 1: Les interfaces homme-machine et le langage Java 22.

public class BoiteMessage {

Chapitre 1: Les interfaces homme-machine et le langage Java 23.

 Les conteneurs intermédiaires peuvent contenir d’autres conteneurs intermédiaires.

 Swing comporte plusieurs conteneurs intermédiaire : JPanel, JScrollPane, JSplitPane,

Chapitre 1: Les interfaces homme-machine et le langage Java 24.

void setLayout(LayoutManager) associe au Conteneur l’objet de placement passé en

Chapitre 1: Les interfaces homme-machine et le langage Java 25.

 Création d'un JPanel:

Chapitre 1: Les interfaces homme-machine et le langage Java 26.

Chapitre 1: Les interfaces homme-machine et le langage Java 27.