05 - Labo Sun - Cours - Swing Base - 4.0

http://www.labo-sun.
com
labo-sun@supinfo.com
Les bases de Swing

INTERFACE HOMME-MACHINE
Auteur : Maxime Vialette

Version n° 0.1 – 16 octobre 2006
Nombre de pages : 61
Ecole Supérieure d’Informatique de Paris

23. rue Château Landon 75010 – PARIS
www.supinfo.com
Les bases de Swing – Interface Homme- 2 / 61
Machine
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Machine
Table des matières

1. INTRODUCTION......................................................................................................................................... 5
2. LES JAVA FOUNDATION CLASSES....................................................................................................... 6
2.1. API AWT ................................................................................................................................................. 6
2.2. API SWING ............................................................................................................................................... 6
2.3. API JAVA2D............................................................................................................................................. 6
2.4. DRAG & DROP .......................................................................................................................................... 6
2.5. API ACCESSIBILITY & INTERNATIONALIZATION ...................................................................................... 6
3. FONCTIONNEMENT D’UNE APPLICATION GRAPHIQUE .............................................................. 8
3.1. ARCHITECTURE GLOBALE ......................................................................................................................... 8
3.2. ÉCRITURE DE L’APPLICATION ................................................................................................................... 9
3.2.1. Création de la classe ........................................................................................................................ 9
3.2.2. Déclaration des composants graphiques.......................................................................................... 9
3.2.3. Initialisation de l’interface graphique.............................................................................................. 9
3.2.4. Définir le conteneur racine............................................................................................................. 10
3.2.5. Lancement de l’application ............................................................................................................ 11
4. LES COMPOSANTS SWING ................................................................................................................... 12
4.1. LES CONTENEURS DE HAUT NIVEAU ........................................................................................................ 13
4.1.1. Le conteneur JFrame...................................................................................................................... 13
4.1.2. Le conteneur JDialog ..................................................................................................................... 14
4.1.3. Le conteneur JWindow ................................................................................................................... 17
4.1.4. Le conteneur JApplet ...................................................................................................................... 17
4.2. LES CONTENEURS D’USAGE GENERAL ..................................................................................................... 19
4.2.1. Le conteneur JPanel ....................................................................................................................... 19
4.2.2. Le conteneur JScrolPane................................................................................................................ 20
4.2.3. Le conteneur JSplitPane................................................................................................................. 20
4.2.4. Le conteneur JTabbedPane ............................................................................................................ 21
4.2.5. Le conteneur JToolBar ................................................................................................................... 22
4.3. LES CONTENEURS SPECIFIQUES ............................................................................................................... 23
4.3.1. JRootPane....................................................................................................................................... 23
4.3.2. ContentPane ................................................................................................................................... 23
4.3.3. JMenuBar ....................................................................................................................................... 24
4.3.4. GlassPane....................................................................................................................................... 25
4.3.5. JLayeredPane ................................................................................................................................. 26
4.3.5.1. JDesktopPane ........................................................................................................................................... 27
4.3.5.2. JInternalFrame .......................................................................................................................................... 28
5. LES COMPOSANTS COURANTS ........................................................................................................... 29
5.1. LA CLASSE JCOMPONENT ....................................................................................................................... 29
5.2. LES COMPOSANTS BOUTONS ................................................................................................................... 29
5.2.1. AbstractButton ................................................................................................................................ 29
5.2.2. JButton............................................................................................................................................ 30
5.2.3. JRadioButton .................................................................................................................................. 32
5.3. LES COMPOSANTS TEXTE ........................................................................................................................ 33
5.3.1. Le JLabel ........................................................................................................................................ 33
5.3.2. La classe JTextComponent ............................................................................................................. 36
5.3.3. JTextField ....................................................................................................................................... 36
5.3.4. JFormattedTextField ...................................................................................................................... 36
5.3.5. JPasswordField .............................................................................................................................. 36
5.3.6. JTextArea........................................................................................................................................ 37
5.3.7. JEditorPane.................................................................................................................................... 39
5.3.8. JTextPane ....................................................................................................................................... 40
5.3.9. Options de style et de formatage ............................................................ Erreur ! Signet non défini.
Machine
5.4. COMPOSANTS PROPOSANT UNE LISTE DE VALEURS ................................................................................. 41

5.4.1. JCheckBox ...................................................................................................................................... 41
5.4.2. JComboBox..................................................................................................................................... 42
5.4.3. JList ................................................................................................................................................ 43
5.4.4. JSpinner.......................................................................................................................................... 45
5.4.5. JSlider............................................................................................................................................. 45
5.5. LES COMPOSANTS DE MENU .................................................................................................................... 46
5.5.1. JMenuBar ....................................................................................................................................... 46
5.5.2. JPopupMenu................................................................................................................................... 46
5.5.3. JMenu ............................................................................................................................................. 46
5.5.4. JMenuItem ...................................................................................................................................... 46
5.5.5. JCheckBoxMenuItem ...................................................................................................................... 46
5.5.6. JRadioButtonMenuItem .................................................................................................................. 47
5.6. LES COMPOSANTS INFORMATIFS NON EDITABLES ................................................................................... 48
5.6.1. JProgressBar .................................................................................................................................. 48
5.6.2. JToolTip.......................................................................................................................................... 48
5.7. LES CONTROLES DE HAUT-NIVEAU.......................................................................................................... 49
5.7.1. JColorChooser ............................................................................................................................... 49
5.7.2. JFileChooser .................................................................................................................................. 49
5.7.3. JTable ............................................................................................................................................. 49
5.7.4. JTree ............................................................................................................................................... 49
6. LA GESTION DES EVENEMENTS......................................................................................................... 50
6.1. PRINCIPE ................................................................................................................................................. 50
6.2. LES CLASSES D’EVENEMENTS ................................................................................................................. 50
6.2.1. Principe .......................................................................................................................................... 50
6.3. UTILISATION ........................................................................................................................................... 51
6.4. ÉVENEMENTS SPECIFIQUES ..................................................................................................................... 51
6.4.1. Evénements de java.awt.event ........................................................................................................ 51
6.4.2. Evénements de javax.swing.event ................................................................................................... 52
6.5. LES LISTENERS D’EVENEMENTS .............................................................................................................. 52
7. UTILISATION DES “MODELES”........................................................................................................... 55
8. AUTRES FONCTIONNALITES............................................................................................................... 56
8.1. LE LOOK-AND-FEEL ................................................................................................................................ 56
8.2. LE MODE DE DISTRIBUTION D’APPLICATIONS JAVA................................................................................. 57
8.3. CHARGEMENTS DES RESSOURCES SITUEES DANS UN JAR ........................................................................ 58
8.4. JAVA WEB START ................................................................................................................................... 59
8.5. INTERNATIONALISATION (I18N) ............................................................................................................. 60
9. CONCLUSION............................................................................................................................................ 61
Machine
1. Introduction
Dans de nombreux langages de programmation, tels que le C++, la réalisation d’interfaces utilisateur
graphiques a posé de nombreux problèmes aux développeurs. De plus, en Java les interfaces doivent
être portables d’un système d’exploitation à un autre et offrir des fonctions d’accessibilité puissantes
(raccourcis, internationalisation des applications, …)
Swing constitue la solution la plus employée pour réaliser des interfaces graphiques en Java car c’est
une logique simple et efficace à mettre en œuvre.
Swing reprend beaucoup de concept d’AWT (Abstract Window Toolkit), l’ancienne API permettant
de réaliser des applications graphiques. Toute la gestion des événements est d’ailleurs toujours
centralisée dans l’API d’AWT, Swing a simplement ajouté de nouveaux composants graphiques avec
de nouvelles fonctionnalités.
Une autre librairie existe. Connue sous le nom de SWT (Standard Widget Toolkit), cette librairie
permet de se reposer de façon transparente sur la couche graphique du système d’exploitation (GTK
pour linux, Carbon pour MacOSX, …). Les applications sont donc mieux intégrées à l’environnement
de l’utilisateur, comme Eclipse. SWT n’est cependant pas compatible avec Swing ou AWT. De plus,
cette librairie est trop dépendante d’élément non-Java, donc cela pose certains problèmes de
portabilité.
Machine
2. Les Java Foundation Classes

Il s’agit d’un ensemble de librairies Java fournies avec Java SE afin de permettre la création
d’interfaces graphiques (GUI) et de fonctionnalités graphiques.
2.1. API AWT

Cette API existe depuis la version 1.0 de JAVA. Les composants appartenant à l’API AWT sont dits
lourds, car ils s’appuient sur le système d’exploitation sous-jacent pour dessiner les composants.
Cependant, dans la version 1.1 de Java, AWT a été étendue pour permettre la création de composants
dits « légers » ne s’appuyant pas sur le système d’exploitation. Ceci peut causer des problèmes, surtout
au niveau de la portabilité, car les composants ont l’aspect du système sur lequel ils s’exécutent, ce qui
peut créer des problèmes d’un système à un autre.
2.2. API Swing

Cette API est apparue en même temps que les JFC (Java Foundation Classes) dont elle constitue la
pierre angulaire. Cette API est totalement écrite en langage Java et s’avère être totalement portable.
Cependant, Swing n’a pas pour vocation de remplacer AWT, mais plutôt de la compléter.
2.3. API Java2D

Cette API permet la gestion des graphiques bidimensionnels. Ainsi, il sera aisé d’ajouter du texte et
des graphiques de qualité dans nos applications. De plus, de nombreuses fonctions utilitaires sont
disponibles : gestion de l’impression, représentation de graphiques, rotation, mise à l’échelle, lissage
de texte, etc.
2.4. Drag & Drop

Cette API permet les transferts de données entre des applications indépendantes. Ainsi, le copier-coller
et le glisser-déplacer sont implémentés.
2.5. API Accessibility & Internationalization

L’API Accessibility permet d’utiliser des fonctions d’assistance diverses à l’attention, entre autres, des
déficients physiques.
L’API Internationalization permet au développeur de créer des applications multilingues qui

s’adaptent au contexte géographique et culturel (nous apprendrons à nous en servir dans cet essentiel).
Machine
Machine
3. Fonctionnement d’une application

graphique
3.1. Architecture globale

Une application graphique est un emboitement d’objets.
On utilise des objets « conteneurs » pour rassembler par groupe les composants que l’on affiche. Il
peut s’agir de fenêtres, ou bien des « Panels », qui sont plus discrets mais permettent d’organiser la
disposition.
Dans l’interface utilisateur que nous voyons ci-dessus, nous pouvons dénombrer des conteneurs :
- La fenêtre, du type JFrame

- La liste des villes, dans un JPanel
- L’entrée « jContentPane », qui est le panel principale de la fenêtre.
Les composants que l’on affiche sont des champs de texte, mais il en existe beaucoup d’autres
(boutons, listes déroulantes, etc.).
Machine
3.2. Écriture de l’application

Dans l’exemple que nous allons voir, nous allons écrire une fenêtre qui contiendra des Labels (champs
texte non éditables). Lorsque vous exécuterez l’application, vous devriez voir l’équivalent de
l’interface graphique vue plus haut.
L’intérêt n’est pas d’expliquer les composants de façon précise, nous le ferrons dans les chapitres
suivants, mais de pouvoir déclarer une première interface graphique.
3.2.1. Création de la classe
Nous allons créer une classe nommée TravelMonth, située dans le package
com.labosun.swing.exercise1 :
package com.labosun.swing.exercise1;
// import awt and swing objects

import java.awt.*;
import javax.swing.*;
public class TravelMonth extends JFrame {
…
}
Nous allons par la suite écrire le code de cette classe.
3.2.2. Déclaration des composants graphiques
Nous déclarons maintenant tous les composants dont nous avons besoin. Les explications sur chaque
composant sont en commentaire dans le code :
// optional field, used by Serialization
private static final long serialVersionUID = 1L;
// root container of the JFrame

private JPanel jContentPane = null;
// enclose some jlabels

private JPanel jPanel = null;
// display text informations

private JLabel travel1 = null;
private JLabel jLabel = null;
3.2.3. Initialisation de l’interface graphique
Dans un premier temps, le constructeur initialise la fenêtre, de type JFrame, et ici représentée par le
mot clé this.
Machine
/**
* This is the default constructor
*/
public TravelMonth() {
super();
initialize();
}
/**
* This method initializes "this"
*
* @return void
*/
private void initialize() {
// define the size of the frame
this.setSize(300, 200);
// define the default operation when

// the frame is closed
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// define which panel is the root panel

this.setContentPane(getJContentPane());
// define the title of the frame

this.setTitle("Travel Agency");
}
3.2.4. Définir le conteneur racine
Le conteneur correspond à la variable « jContentPane ». Nous allons l’instancier dans la méthode

suivante :
/**
* This method initializes jContentPane
*
* @return javax.swing.JPanel
*/
private JPanel getJContentPane() {
// if the jContentPane has not been initialized yet
if (jContentPane == null) {
// create an instance of JPanel

jContentPane = new JPanel();
// display the following phrase "Travels during this month : "

// on the top of your application
jLabel = new JLabel();
jLabel.setText("Travels during this month :");
jContentPane.add(jLabel);
// dispose a panel at the center of the frame

jContentPane.add(getJPanel());
}
return jContentPane;
}
La méthode getJPanel() n’a pas encore été vue. Voici son contenu :
/**
* This method initializes jPanel
Machine
*
* @return javax.swing.JPanel
*/
private JPanel getJPanel() {
// if this object has not been initialized yet
if (jPanel == null) {
// create an instance of JPanel
jPanel = new JPanel();
// the jPanel variable contains the

// following 3 labels, which are
// also initialized in the current method
travel3 = new JLabel();
travel3.setText("Shanghai");
travel2.setText("Beijing");
travel1.setText("Madrid");
// add the labels to the jPanel

jPanel.add(travel1, null);
}
return jPanel;
}
3.2.5. Lancement de l’application
La méthode main(…) sert de point d’entrée dans notre application.
/**
* This is the entry point of the application
*
* @param args
*/
public static void main(String[] args){
TravelMonth exercice = new TravelMonth();
// a JFrame is not visible by default

exercice.setVisible(true);
}
Machine
4. Les composants Swing

Il existe beaucoup de composants Swing et nous allons devoir les regrouper par ensemble :
- Les composants de haut niveau : les fenêtres (JFrame, JDialog, etc.)

- Les conteneurs d’usage général : les onglets (JTabbedPane), le scrolling (JScrollPane), les
panels (JPanel), …
- Les conteneurs spécifiques : les fenêtres interne, appelées aussi MDI (JDesktopPane), utiliser
des calques (JLayeredPane),
- Les contrôles courants : les boutons (JButton), les listes (JList), les menus (JMenu), …
- Les composants graphiques non-éditables : barre de progression (JProgressBar), …
- Les contrôles de haut-niveau : les sélecteurs de fichiers (JFileChooser), les tableurs (JTable),
les explorateurs (JTree), …
En rappel du chapitre précédent, « conteneurs » sont des composants servant à en contenir d’autres.
Par exemple dans l’arbre des composants suivant nous pouvons dénombrer un JFrame (à la racine), un
JPanel comme conteneur principale pour le JFrame (jContentPane) ainsi qu’un second regroupant 3
labels. Le dernier est la barre de menu, appelé jJMenuBar :
Machine
4.1. Les conteneurs de haut niveau

4.1.1. Le conteneur JFrame
Cette classe se situe, comme beaucoup d’autres, dans le package javax.swing. Dans une application
Swing, le conteneur principal est une JFrame (Fenêtre). Une de ses propriétés se nomme rootPane,
une instance de JRootPane (Panneau Racine), et c’est à ce conteneur que l’on ajoutera des
composants. Nous reviendrons sur ce composant un peu plus tard.
Nous allons voir en détails tous ces objets dans la suite du cours.
Ci-dessous, nous allons présenter les principales méthodes de la classe JFrame.

Parmi les constructeurs de la classe JFrame :
o JFrame() crée une nouvelle fenêtre initialement invisible
o JFrame(String) crée une nouvelle fenêtre initialement invisible avec un titre spécifié
Méthodes utiles de la classe JFrame :

o getContentPane() retourne le contentPane de la fenêtre
o add(Component c) ajoute un composant au ContentPane de la fenêtre
o setDefaultCloseOperation(int) spécifie l’action de fermeture par défaut
o setJMenuBar(JMenuBar menu) attribue un menu à cette fenêtre
o setLayout(LayoutManager lay) attribue un Layout qui doit être utilisé par le
ContentPane
o setVisible(boolean) affiche ou fait disparaître la fenêtre (remplace les
méthodes show() et hide() qui sont dépréciées)
o setTitle(String) attribue un titre à la fenêtre
o setSize(int, int) attribue des dimensions à la fenêtre
Machine
4.1.2. Le conteneur JDialog
Peu de choses différencient les classes JFrame et JDialog. JFrame est une fenêtre principale, alors
que JDialog est une fenêtre secondaire, qui peut être modale par rapport à une autre JDialog ou
JFrame. La classe JDialog est utilisée pour afficher des boîtes de dialogue tandis que JFrame est
utilisée en tant que fenêtre principale de l’application.
Une fenêtre de type JDialog s’utilise de la même façon qu’une JFrame. La classe JDialog hérite de
java.awt.Dialog et est utilisée pour créer une boîte de dialogue personnalisée. JDialog est en effet un
conteneur pratiquement identique à JFrame.
Voici les différents constructeurs auxquels vous avez accès :

o JDialog() crée une JDialog non modale, sans titre et sans parent
o JDialog(Dialog, String,boolean) crée une JDialog modale ou non, avec titre et parent
o JDialog(Frame,String,boolean) crée une JDialog modale ou non, avec titre et parent
Une JDialog se positionne dans le coin gauche et haut de l’écran, il faut obligatoirement coder le
placement de la boîte de dialogue, pour obtenir son placement au centre de la fenêtre parent.
Voici un exemple d’utilisation :
La classe JOptionPane fournit une manière facile et pratique d’afficher des boîtes de dialogues
standard.
Une boîte de dialogue standard de type JOptionPane se présente de la manière suivante :
Zone de Message
Zone
d’image
Zone de saisie
(icône)
( JTextField ou JComboBox)
Zone d’options
(Boutons)
Machine
Il est à noter qu’une boîte de dialogue JOptionPane est modale.

JOptionPane n’hérite pas de JDialog, mais directement de JComponent.
A ce titre JOptionPane agit comme un container et peut être placé dans n’importe quel type de
container.
Il est possible d’instancier directement des JOptionPane de la façon suivante :
JOptionPane.showMessageDialog(null, "Votre disque va être entièrement effacé",
"Alerte", JOptionPane.ERROR_MESSAGE);
JOptionPane.showConfirmDialog(null, "Voulez vous quitter l'application",

"Sélection", JOptionPane.YES_NO_OPTION);
Object[] options = {"ACCEPTER", "REFUSER"};
JOptionPane.showOptionDialog(null, "Les valeurs doivent elles êtres définitivement

effacées ?", "Attention", JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,
null, options, options[0]);
Machine
String inputValue = JOptionPane.showInputDialog("Entrez une valeur");
Object[] possibleValues = {"France", "Royaume-Uni", "Allemagne", "Irlande",

"Belgique"};
Object selectedValue = JOptionPane.showInputDialog(null, "Choose one", "Input",
JOptionPane.INFORMATION_MESSAGE, null, possibleValues, possibleValues[0]);
4.1.3. Méthodes showXxxDialog
Quelques méthodes showXxxDialog(), les plus usitées, sont présentées ci-après, toutefois celles-ci
sont plus nombreuses en réalité.
showConfirmDialog(Component Parent,Object Message)
Affiche une DialogBox avec les boutons Oui, Non et Annuler, avec le titre Sélectionnez une option
(on peut passer null comme parent, sinon un JComponent, et l’object peut être une String)
showConfirmDialog(Component Parent, Object Message, String title, int optionType,

int messageType)
Cette méthode permet de personnaliser les icônes affichées et le groupe de boutons associés
showInputDialog(Component Parent, Object message)
Crée une boîte de dialogue de saisie
Machine
showMessageDialog(Component Parent, Object message)
Crée une boîte de dialogue affichant un message
showOptionDialog(Component Parent, Object message, String title, int optionType,

int messageType, Icon icon, Object[] options, Object initialValue)
Crée une boîte de dialogue d’options avec un choix initial (focus), une icône personnalisée, et une liste
de choix (Combo)
Les constantes associées sont les suivantes :
messageType : définit le style de message
• ERROR_MESSAGE
• INFORMATION_MESSAGE
• WARNING_MESSAGE
• QUESTION_MESSAGE
• PLAIN_MESSAGE
optionType : définit le type de boutons d’options qui apparaissent en bas de la boîte de

dialogue.
• DEFAULT_OPTION
• YES_NO_OPTION
• YES_NO_CANCEL_OPTION
• OK_CANCEL_OPTION
Valeurs de retour : lorsqu’une fonction showXxxDialog retourne un entier, les valeurs

possibles sont :
• YES_OPTION
• NO_OPTION
• CANCEL_OPTION
• OK_OPTION
• CLOSED_OPTION
4.1.4. Le conteneur JWindow
JWindow est un cas particulier de fenêtre. Cela ressemble à une JFrame sans « pourtour » (bordure).
Cette fenêtre n’est ni redimensionnable, ni déplaçable par l’utilisateur. Il n’existe pas non plus de
bouton pour fermer l’application, c’est au développeur de programmer la fermeture de ce type de
fenêtre.
La classe JWindow est très utilisée pour coder un splash screen, cette image qui s’affiche au
lancement d’une application pendant la durée de l’initialisation de cette dernière.
4.1.5. Le conteneur JApplet
Machine
Un applet est un petit programme qu’un navigateur capable d’interpréter le Java, par exemple Internet
Explorer ou Netscape Navigator, peut télécharger à partir d’internet et exécuter.
JApplet est une sous classe de java.applet.Applet.
Comme JApplet est un conteneur Swing de haut-niveau, chaque applet Swing a un panneau racine
(root pane), ainsi qu’un content pane unique. Pour ajouter un composant à votre applet, vous devez
donc l’ajouter au content pane de votre JApplet, et pas directement dans l’applet.
Inclure un applet dans une page HTML :
Pour ajouter un applet dans une page HTML, il est recommandé de l’inclure en utilisant la balise
« applet » de cette façon :
<applet code="MonApplet.class"
width="600" height="95">
</applet>
Si vous souhaitez visualiser l’applet que vous avez incluse dans votre page HTML (qu’on appellera
pour l’exemple maPageAvecMonApplet.html), vous pouvez l’exécuter en utilisant l’application
appletviewer, présente dans le JDK, en ligne de commande, de cette façon :
appletviewer maPageAvecMonApplet.html
Vous pouvez également tout simplement charger votre page HTML dans votre navigateur.
Le cycle de vie d’un applet :
Basiquement, il y a quatre méthodes dans la classe Applet :

• init() : Cette méthode est utilisée pour l’initialisation de l’applet. Elle est appelée après les
attributs « param » de la balise « applet ».
• start() : Cette méthode est automatiquement appelée après la méthode init(). Elle est
également appelée chaque fois que l’utilisateur retourne à la page contenant l’applet après
avoir visité d’autres pages.
• stop() : Cette méthode est automatiquement appelée chaque fois que l’utilisateur quitte la page
contenant l’applet. Vous pouvez utiliser cette méthode pour stopper une animation.
• destroy() : Cette méthode est appelée uniquement quand le navigateur est éteint normalement.
Ainsi, l’applet peut être initialisé une et seulement une fois, démarré et stoppé une ou plusieurs fois
dans sa vie, et détruit une et seulement une fois.
Machine
4.2. Les conteneurs d’usage général

4.2.1. Le conteneur JPanel
Le conteneur JPanel est l’un des conteneurs les plus utilisés. Il sert souvent à rassembler les
composants par « groupes » afin de simplifier la disposition.
L’aspect graphique d’un JPanel est réduit au strict minimum, il peut être perçu comme un rectangle,
parfois même invisible graphiquement. Il est possible de modifier la couleur de fond d’un JPanel, sa
taille, sa position, son état (visible, invisible, avec ou sans bordure, etc).
JPanel est un nœud « idéal » dans une arborescence de composants. La création d’un nouveau JPanel
n’est cependant pas obligatoire. En effet, vous pouvez réutiliser le JPanel définit par défaut dans votre
JFrame en utilisant la méthode getContentPane() qui permet de récupérer ce dernier. L’ajout d’un
composant dans un JPanel se fait par le biais de la méthode add(…) héritée de Container.
JFrame myFrame = new Jframe();

JPanel p1 = new JPanel();
JPanel p2 = new JPanel();
JButton button1 = new JButton();
p1.add(button1);
p1.add(button2);
p1.add(button3);
JLabel myLabel = new JLabel();
JTextField myTextField = new JTextField();
p2.add(myLabel);
p2.add(myTextField);
myFrame.getContentPane().add(p1);
myFrame.getContentPane().add(p2);
Voici une représentation hiérarchique de l’ensemble de vos composants :
Exemple d’imbrication des composants de Swing
Machine
4.2.2. Le conteneur JScrolPane
Lorsque le composant que l’on cherche à afficher est trop grand (une image, un tableau, un champ
texte,…), il est alors possible de faire appel au conteneur JScrollPane afin d’utiliser une barre de
défilement.
JScrollPane, contrairement à JPanel, n’accepte qu’un seul composant. Il a un impact graphique plus
important que JPanel du fait de la présence de barre de défilement.
JScrollPane propose une barre de défilement
L’acceptation d’un composant dans un JScrollPane est un processus particulier. En effet, le

JScrollPane forme une vue sur le composant, on n’utilise pas add() mais la méthode
setViewportView(Composant).
Voici un exemple de code :
JScrollPane sp = new JScrollPane(); // déclaration du JScrollPane

JLabel monLabel = new JLabel("Mon Libellé"); // déclaration du libellé
sp.setViewportView(monLabel); // formation de la vue sur le
// composant
fenetre.getContentPane().add(sp); // ajout de JScollPane à la fenêtre
// principale
4.2.3. Le conteneur JSplitPane
JSplitPane est un conteneur qui permet de séparer une fenêtre en deux parties dont les surfaces
peuvent changer dynamiquement. Ce conteneur s’utilise de façon classique, mais il ne peut contenir
que deux composants (ou conteneurs), un de chaque côté de la barre de séparation.
Machine
JSplitPane permet de diviser verticalement une partie de la fenêtre
JSplitPane peut être orienté horizontalement ou verticalement, suivant que l’on utilise les méthodes
suivantes (elles vont par 2) :
o setLeftComponent(composant)
o setRightComponent(composant)
ou
o setTopComponent(composant)
o setBottomComponent(composant)
D’autres méthodes servent, quant à elles, à permettre ou non de redimensionner la taille des deux
parties dynamiquement :
o setContinuousLayout(true) : Dynamique (Modifier)
o setContinuousLayout(false) : Statique (Ne pas Modifier)
Enfin, il existe aussi une méthode qui permet le double clic sur la barre pour la faire apparaître ou
disparaître brusquement.
setOneTouchExpandable(true)
4.2.4. Le conteneur JTabbedPane
Ce conteneur permet d’afficher plusieurs panneaux qui partagent le même espace graphique. L’accès à
chaque panneau se fait par le biais d’onglets le plus souvent situés en haut du conteneur.
JTabbedPane permet de partager l’espace de travail
Les trois constructeurs existants sont les suivants :

o JTabbedPane() : crée un TabbedPane vide par défaut.
o JTabbedPane(int tabPlacement) : spécifie le placement des onglets
Machine
• JTabbedPane.TOP
• JTabbedPane.BOTTOM
• JTabbedPane.LEFT
• JTabbedPane.RIGHT
o JTabbedPane(int tabPlacement, int tabLayoutPolicy) : politique d’affichage des onglets
• JTabbedPane.WRAP_TAB_LAYOUT
• JTabbedPane.SCROLL_TAB_LAYOUT
On peut ensuite créer les onglets un à un à l’aide de la méthode addTab() :
JTabbedPane monPanneau = new JTabbedPane();
JPanel pan1 = new JPanel(new BorderLayout());

JPanel pan2 = new JPanel(new BorderLayout());
...
monPanneau.addTab("Onglet 1", pan1);
monPanneau.addTab("Onglet 1", pan2);
...
getContentPane().add(monPanneau);
4.2.5. Le conteneur JToolBar
La classe JToolBar permet d’avoir une barre d’outils avec des boutons de raccourci.
JToolBar permet de placer des raccourcis dans une barre verticale ou horizontale
…
JToolBar toolBar = new JToolBar();
toolBar.add(new JLabel("mon test"));
myFrame.getContentPane().add(toolBar);
…
Machine
4.3. Les conteneurs spécifiques

4.3.1. JRootPane
Une instance de JRootPane est créée automatiquement par la JFrame lorsque son constructeur fait
appel à la méthode createRootPane().
Le JRootPane ainsi créé contient les éléments suivants :

o ContentPane (un JPanel par défaut)
o MenuBar (un JMenuBar null par défaut)
o GlassPane (un JPanel par défaut)
o LayeredPane (un JLayeredPane)
Voici l’illustration des différents éléments évoqués précédement :

MenuBar
GlassPane
LayeredPane
ContentPane
• ContentPane est un panneau créé lui aussi par défaut. Il reçoit les composants à l’aide de
l’instruction suivante :
maJFrame.getContentPane().add(monComponent)
• MenuBar n’existe pas par défaut (il est à null, donc pas encore instancié). Cependant, on peut
le définir avec la méthode suivante :
setJMenuBar(menu);
• GlassPane est transparent et s’avère très utile lorsqu’il va s’agir d’intercepter des événements
générés par la souris.
• LayeredPane correspond à un type particulier (JLayeredPane), et il va permettre de contenir
des fenêtres filles à l’instar des applications MDI de Microsoft.
Nous allons étudier d’avantage ces quatre derniers objets.
4.3.2. ContentPane
Il sagit du conteneur associé au JRootPane, et qui contient l’ensemble des composants que nous
détaillerons plus tard (les boutons, les listes, …).
Machine
4.3.3. JMenuBar
JMenuBar est une barre de menus. Il ne peut en exister qu’une seule par JFrame.
Une instance de JMenuBar est composée de plusieurs instances de JMenu, qui sont les éléments
visibles directement dans la barre de menus.
Chaque instance de JMenu peut contenir plusieurs instances de JMenuItem, qui sont les éléments
visibles quand l’utilisateur clique sur un menu.
JMenuBar permet d’afficher des … barres de menu
Voici la liste des méthodes les plus utilisées afin de construire une fenêtre avec une barre de menus :
o Classe JMenuBar
• JMenuBar() Constructeur unique.
• add(JMenu) Méthode d’ajout d’un menu à la barre de menus.
o Classe JMenu
• JMenu() Constructeur par défaut.
• JMenu(String s) Constructeur d’un menu avec son libellé
• add(JMenu) Méthode d’ajout d’un JMenu au menu afin d’obtenir des
sous-menus.
• add(JMenuItem item) Méthode d’ajout d’un JMenuItem au menu
• addSeparator() Méthode d’ajout d’une barre de séparation
o Classe JMenuItem (Elément de menu)

• JMenuItem() Constructeur par défaut
• JMenuItem(String s) Constructeur d’un élément de menu avec son libellé
• addActionListener(ActionListener al) Méthode d’ajout de Listener, permettant la
gestion des événements (nous verrons les
Listener plus loin dans ce document).
o Classe JFrame
• setJMenuBar(JMenuBar menu) Méthode pour transmettre une barre de
menus à JFrame.
Machine
Nous reviendrons sur ce composant de façon plus détaillée dans la partie sur les contrôles basiques.
4.3.4. GlassPane
Le composant GlassPane représente un panneau transparent positionné au dessus du JRootPane

permettant de capturer les événements de souris.
Le GlassPane par défaut est accessible via les méthodes getGlassPane() et setGlassPane(Component
c) de l’interface RootPaneContainer implémentées par les conteneurs ayant un JRootPane.
Ce composant agit comme un calque qui recouvre notre conteneur et qui peu intercepter les
évènements ou superposer des éléments graphique. Par exemple, on peut utiliser le composant
GlassPane pour désactiver tout un ensemble de composants en intercepetant leurs évènements. On
peut également l’utiliser pour superposer des éléments graphiques.
En pratique, on personnalise notre propre GlassPane afin de l’affecer au GlassPane par défaut via la
méthode setGlassPane(Component c). Dans ce cas précis, l’objet en paramètre serait notre GlassPane
personnalisé.
Voici un exemple de code permetttant représentant un composant GlassPane personnalisé :
// Crée une classe représentant notre GlassPane personnalisé.

// Ce GlassPlane est un JComponent qui implémente ItemListener pour la gesion des
// évènements.
class MonGlassPane extends JComponent implements ItemListener {
Point point;
//Réagit au changement d’état d’un élément. Affiche ou cache la GlassPane.

//Quand l’élément est sélectionné alors le GlassPane est visible sinon non.
public void itemStateChanged(ItemEvent e) {
setVisible(e.getStateChange() == ItemEvent.SELECTED);
}
//Dessine un point rouge sur la GlassPane selon les coordonnées du point.

protected void paintComponent(Graphics g) {
if (point != null) {
g.setColor(Color.red);
g.fillOval(point.x - 10, point.y - 10, 20, 20);
}
}
//Modifie la position du point.

public void setPoint(Point p) {
point = p;
}
//Constructeur créant un écouteur personnalisé pour les différents éléments de

//la fenêtre.
//Redirige les écouteur de mouvement et de clique de souris vers l’écouteur
//personnalisé.
public MyGlassPane(AbstractButton aButton, JMenuBar menuBar,
Container contentPane) {
CBListener listener = new CBListener(aButton, menuBar,

this, contentPane);
addMouseListener(listener);
addMouseMotionListener(listener);
}
}
Machine
4.3.5. JLayeredPane
JLayeredPane est un conteneur qui peut posséder un nombre de couches. Les composants contenus
dans un Layer (une couche de JLayeredPane) sont organisés selon leur position dans un
environnement en « 3 Dimensions » : hauteur, largeur et profondeur.
JLayeredPane permet de définir une profondeur aux éléments contenus
Chaque JLayeredPane est caractérisé par la possibilité d’ajouter un composant à une couche. Pour
définir la priorité de cette couche on doit préciser une priorité. Une valeur de type Integer donne ainsi
la priorité de la couche par rapport aux autres. Cette prioritée joue également sur l’ordre d’affichage.
En effet, plus la valeur est grande plus le panel sera prioritaire et donc mise en avant.
Par exemple, lorsque l’on souhaite ajouter un composant JLabel dans notre JLayeredPane, on
spécifie une valeur de type Integer définissant dans quel couche il sera ajoutée.
Pour cela nous avons deux manières de procéder.
D’une manière personnalisée en attribuant une valeur de type Integer en second paramètre.
layeredPane.add(label, new Integer(1));
D’une manière prédéfinie, le JLayeredPane prévoit des valeurs par défaut stocké dans des constantes.
layeredPane.add(label, JLayeredPane.DEFAULT_LAYER);
Machine
La profondeur (Depth)
Lorsqu’un composant est contenu dans un Layer (couche), ce dernier s’appropie la priorité du Layer.
Mais, un composant est aussi représenté par son index. L’index est une valeur entière différente pour
chacun des composants du JLayeredPane. On peut interroger un composant pour connaître son index,
mais on ne peut pas changer l’index d’un composant.
Chaque Layer d’un JLayeredPane est représenté par un objet Integer.

La classe JLayeredPane définit les six constantes Integer. Voici dans l’ordre du moins prioritaire au
plus prioritaire.
o FRAME_CONTENT_LAYER
o DEFAULT_LAYER
o PALETTE_LAYER
o MODAL_LAYER
o POPUP_LAYER
o DRAG_LAYER
L’ajout de Layer
Lorsque l’on ajoute un composant au JLayeredPane à l’aide de la méthode add(Component), celui-ci
est placé dans le Layer DEFAULT_LAYER (représenté par Integer(0));
Pour ajouter un composant à un Layer particulier, on utilise la méthode add(Component, Object).
Pour le Layer 10 par exemple, on passera l’objet Integer(10).
On peut aussi passer les valeurs des Layers standards, par exemple JLayeredPane.POPUP_LAYER
Pour ajouter un composant à un Layer particulier et à une position donnée, on utilisera la méthode
add(Component composant, Object obj, int position).
4.3.5.1. JDesktopPane
JDesktopPane est une extension de JLayeredPane spécialement construite pour gérer des fenêtres
filles du type JInternalFrame. Il est plus souvent utilisé que JLayeredPane car plus fonctionnel.
JDesktopPane permet de gérer des sous-fenêtres
JDesktopPane permet d’ajouter des composants à l’aide de la méthode add(Component).
Dans le cas de JDesktopPane, le composant que l’on va ajouter est un objet de la classe
JInternalFrame qui correspond aux fenêtres filles d’une application MDI.
Machine
En plus de la méthode add(), d’autres méthodes peuvent être utiles, comme :

o JInternalFrame [] getAllFrames() : retourne une collection de JInternalFrame actuellement
affichées dans le JDesktopPane.
o setSelectedFrame(JInternalFrame f) : rend la JInternalFrame « f » active.
Il est accessible par le biais des méthodes getContentPane() et setContentPane(Container c) de

l’interface RootPaneContainer implémentées par les conteneurs ayant un JRootPane.
4.3.5.2. JInternalFrame
JInternalFrame est une fenêtre qui peut être déplacée, agrandie, réduite, iconifiée, … à l’intérieur
d’un JDesktopPane. JInternalFrame contient un JRootPane comme JFrame. On peut donc avoir
accès à son GlassPane, ContentPane, LayeredPane, et MenuBar. On va donc agir comme on le faisait
avec JFrame.
Voici ci-dessous des méthodes utiles :

o setLocation(int x, int y) définit la position de la JInternalFrame.
o setLocationRelativeTo(null) positionne selon le centre de l’écran.
o setSize(int,int) définit la taille de la fenêtre.
o setDefaultCloseOperation() ici, on donnera la constante :
• HIDE_ON_CLOSE
• DISPOSE_ON_CLOSE
• DO_NOTHING_ON_CLOSE
o setResizable(boolean) définit si la fenêtre peut être retaillée ou non.
o setIconifiable(boolean) définit si la fenêtre peut être iconifiée ou non
o setIcon(boolean) iconifie / desiconifie la fenêtre.
o setMaximizable(boolean) définit si la fenêtre peut être agrandie ou non
o setMaximum(boolean) maximise la fenêtre ou revient à la taille normale
o setClosable(boolean) définit si la fenêtre peut être fermée ou non
o setClosed(boolean) ferme la fenêtre
Machine
5. Les composants courants

Jusqu’ici nous avions seulement abordé le cas des « conteneurs », cependant, ce qui fait la véritable
richesse d’une interface graphique est l’utilisation des composants : les boutons, les champs de saisi,
les images, etc. Nous allons maintenant voir ceux les plus communs, et les plus simples à mettre en
œuvre.
5.1. La classe JComponent

La classe JComponent est la classe mère de tous les composants Swing hormis les conteneurs de haut
niveau. Elle étend la classe java.awt.Container.
Elle apporte de nombreuses fonctionnalités aux composants Swing, tel que le support des bordures, la
possibilité d’associer des icônes aux composants, le support des ToolTips, etc.
Les principales méthodes de ce composant sont :

o JComponenent() Constructeur par défaut
o createToolTip() Crée une bulle d’aide
o getBorder() Retourne la bordure du composant ou null si elle n’est
pas définie
o getPreferredSize() Retourne la taille préférée
o getMinimumSize() Retourne la taille minimale
o getMaximumSize() Retourne la taille maximale
o paint(Graphics g) Dessine le composant
o requestFocus() Demande à avoir le focus
o setVisible(boolean aFlag) Définit si le composant est visible ou non
o setBackground(Color bg) Définit la couleur de fond
o setBorder() Définit la bordure
o setDoubleBuffered(boolean aFlag) Définit si le double buffering sera utilisé
o setPreferredSize() Définit la taille préférée
o setMinimumSize() Définit la taille minimale
o setMaximumSize() Définit la taille maximale
o setToolTipText(String text) Crée une bulle d’aide avec le texte spécifié
o setVisible(boolean aFlag) Définit t si le composant sera affiché ou non
5.2. Les composants boutons
La classe AbstractButton est la classe de base à partir de laquelle dérivent plusieurs autres
composants. Vous n’utiliserez pas directement la classe AbstractButton, car, comme son nom
l’indique, cette classe ne peut pas être instanciée. Vous devrez donc utiliser une des classes filles
suivantes :
5.2.1. AbstractButton
Machine
Ce composant abstrait fournit les éléments communs aux boutons ainsi qu’aux entrées dans la barre de
menu. On remarque qu’il hérite de JComponent, et donc de tous les comportements qui en découlent
(affichage d’une bordure, définition d’une taille par défaut,…).
Cette classe proprose des éléments intéressants qui servent à la gestion des évènements d’un bouton,
lorsqu’on le clic par exemple :
• void addActionListener(ActionListener l)
Ajoute un ActionListener au bouton (nous traiterons de cette interface plus tard).
• ActionListener[] getActionListeners()
Retourne la liste des ActionListener inscrit aux évènements du bouton.
• void removeActionListener(ActionListener l)
Supprime l’ActionListener spécifié en paramètre.
• void doClick()
Simule un clic "click".
• protected void fireActionPerformed(ActionEvent event)
Simule un événement.
• String getActionCommand()
• void setActionCommand(String actionCommand)
Définie/Retourne l’identifiant du bouton. Cet identifiant permet de savoir exactement quel composant
a généré l’événement.
• void setEnabled(boolean b)
Active (ou désactive) le bouton.
Autres méthodes couramment utilisées :
• void setText(String text)
Définit le texte affiché par le bouton
• void setUI(ButtonUI ui)
Définit le Look&Feel qui rend ce composant.
5.2.2. JButton
JButton est un bouton poussoir classique très simple. Tout ce que nous savons sur JLabel s’applique
à un JButton. Nous pouvons lui ajouter des images, spécifier l’alignement, ou encore appliquer des
Machine
couleurs d’arrière et d’avant plan. De plus, nous pouvons ajouter des Listeners (ActionListener,
ChangeListener, ItemListener) pour capturer les événements. Nous reviendrons en détail sur cette
partie dans le chapitre 10 : « Erreur ! Source du renvoi introuvable. » qui y est dédié.
Méthodes et classes de base :
o JButton() Crée un bouton sans image et sans texte
o JButton(Icon) Crée un bouton avec une image
o JButton(String) Crée un bouton avec un texte
o JButton(String, Icon) Crée un bouton avec un texte et une image
o setHorizontalAlignement(int) Définit l’alignement horizontal du contenu
o setVerticalAlignement(int) Définit l’alignement horizontal du contenu
o setHorizontalTextPosition(int) Définit la position du texte relativement à l’image
o setVerticalTextPosition(int) Idem mais sur l’axe des y
o setIcon(Icon icon) Permet de spécifier ou de remplacer à tout moment
l’image du bouton
o setPressedIcon(Icon) Permet de spécifier une image lorsque le bouton est
pressé
o setRolloverIcon(Icon) Permet de spécifier une image lorsque le bouton est
survolé
o getText() Récupère le texte du bouton
o getIcon() Récupère l’icône du bouton
o setIcon(Icon) Permet de spécifier l’image du bouton
o setText(String) Permet de spécifier le texte pour le bouton (supporte
le html)
o setMnemonic(char) Crée un raccourci vers un caractère
(ex : setMnemonic('C') correspond à « Alt+C »)
o addActionListener(ActionListener) Ajouter le bouton à un ActionListener
o setEnabled(boolean) Activer / Désactiver le bouton
o setActionCommand(String) Permet de définir une commande liée au Listener du
bouton
Dans votre application, il se peut également que vous souhaitiez définir le bouton par défaut parmi
tous les boutons présents. Pour cela, vous devrez utiliser la méthode setDefaultButton(JButton
button) de votre RootPane.
Voici le code illustrant ce principe :
JFrame myFrame = new JFrame("Commercial Survey");

JButton btnSend = new JButton("Send");
myFrame.add(btnSend);
Voici un exemple de bouton affichant « Send » :
On remarquera également JToggleButton, qui est une variante du JButton. En effet, il s’affiche
d’une façon particulière une fois qu’il a été sélectionné (en fonction du Look & Feel sélectionné).
Machine
5.2.3. JRadioButton
Un JRadioButton est un bouton radio. Il s’utilise comme la classe JCheckBox, mais permet de
spécifier qu’il n’y a qu’un seul choix possible parmi toutes les propositions offertes par l’interface
graphique.
La classe JRadioButton doit cependant être utilisée conjointement avec la classe ButtonGroup si
vous souhaitez obtenir le comportement standard de choix unique parmi tous les choix proposés.
La classe ButtonGroup permet donc de regrouper des boutons qui peuvent mettre en place un
mécanisme de sélection basé sur l’exclusion mutuelle (comme avec les boutons radio classiques). Il
suffit pour cela de grouper les boutons en question dans une instance de ButtonGroup, à l’aide de la
méthode add(Button).
Dans le code suivant, nous allons instance des objets de type JRadioButton puis nous les plaçons
dans un ButtonGroup.
…
/****************************
* create radio buttons *****
****************************/
// mario choice
JRadioButton buttonMario =
new JRadioButton("<html>Mario Bros</html>");
// this one is selected by default
buttonMario.setSelected(true);
// sonic choice
JRadioButton buttonSonic =
new JRadioButton(
"<html>Sonic the hedgehog</html>");
// warcraft choice
JRadioButton buttonWarcraft =
new JRadioButton(
"<html>Warcraft</html>");
// group the radio buttons together

ButtonGroup group = new ButtonGroup();
group.add(buttonMario);
group.add(buttonSonic);
group.add(buttonWarcraft);
…
Afin de récupérer l’élément sélectionné, nous devons appelé la méthode

« ButtonGroup.getSelection() ». Nous récupérerons ainsi le modèle de bouton radio sélectionné. Nous
verrons plus tard l’intérêt d’un modèle mais retenons pour l’instant qu’il s’agit d’un objet contenant
les données et les états du composant.
Voici un exemple d’application utilisant les boutons radio :
Machine
Nous avons pu remarquer également la syntaxe HTML que nous venons d’utiliser pour spécifier les
couleurs des zones de texte.
5.3. Les composants texte

5.3.1. Le JLabel
Lorsque vous réalisez une application graphique, il est important d’y ajouter suffisament de libellés
afin de faciliter l’ergonomie de cette dernière. Vous devrez pour cela utiliser la classe JLabel qui est
l’un des composants Swing les plus simples. Il permet d’afficher du texte, des icônes, ou les deux, et
cela dans n’importe quelle position.
Voici un descriptif des méthodes les plus employées :

o JLabel() Crée un libellé sans image et avec une chaîne
vide pour titre
o JLabel(Icon) Crée un libellé avec une image
o JLabel(Icon, int) Crée un libellé avec une image alignée
horizontalement
o JLabel(String) Crée un libellé avec du texte
o JLabel(String, int) Crée un libellé avec du texte aligné
horizontalement
o JLabel(String, Icon , int) Texte + image et alignement horizontal
o setHorizontalAlignement(int alignement) Définit l’alignement horizontal du contenu
o setVerticalAlignement(int alignement) Définit l’alignement horizontal du contenu
o setHorizontalTextPosition(int) Définit la position du texte relativement à
l’image
o setVerticalTextPosition(int textPosition) Idem mais sur l’axe des y
o setIcon(Icon) Permet de spécifier ou de remplacer à tout
moment l’image du libellé
o setText(String) Permet de spécifier le texte pour le label
(supporte certaines balises html)
…
jLabel = new JLabel();
Machine
jLabel.setText("JLabel");
…
L’application suivante utilise des JLabel afin d’afficher un message :
Si vous souhaitez ajouter une image dans votre JLabel, vous devrez utiliser la classe ImageIcon en
spécifiant dans le constructeur le chemin vers l’image gif : ImageIcon(String filename)
…
pictureLabel = new JLabel();
pictureLabel.setText("");
// load the picture thanks to the ClassLoader,

// this is required in order to load a picture from a jar
URL iconURL = getClass().getResource("/age/0.jpg") ;
pictureLabel.setIcon(imageIcon);
…
Nous reparlerons du ClassLoader à la fin de cet essentiel.

Dans l’application suivante, nous avons utilisé un JLabel afin d’afficher une image :
Par défaut, l’alignement horizontal est à gauche pour un libellé de texte seulement. Pour un libellé
contenant une image, l’alignement est au centre.
Machine
Pour spécifier l’alignement, on peut utiliser l’interface SwingConstants de la manière suivante :

• SwingConstants.LEFT
• SwingConstants.CENTER
• SwingConstants.RIGHT
• SwingConstants.TOP
• SwingConstants.BOTTOM
Voici un diagramme des différents positionnements possibles :
Machine
5.3.2. La classe JTextComponent
Il s’agit de la classe de base pour les composants Swing utilisant du texte. Il fournit de nombreuses
fonctionnalités concernant la manipulation du texte, concernant des composants que nous allons voir :
JTextField, JTextArea, JEditorPane.
5.3.3. JTextField
Ce composant est l’un des plus simples à utiliser pour la saisie de données. Il ne permet de saisir
qu’une seule ligne de texte et ne prend pas en compte les styles (gras, italique …).
On peut utiliser l’un des deux constructeurs suivants :
o JTextField() : Crée un champ de saisie vide
o JTextField(String text) : Crée un champ de saisie avec un texte par défaut
Si vous souhaitez récupérer le contenu du champ de saisie, il vous faudra utiliser la méthode getText()
qui vous retournera un objet de type String.
5.3.4. JFormattedTextField
Cette classe hérite de JTextField en ajoutant le support du formattage de valeurs.
5.3.5. JPasswordField
Ce composant permet de créer un champ pour la saisie des mots de passe. Il s’utilise de la même
manière que le composant précédent, mais, lorsque vous saisissez un caractère, celui-ci est remplacé
par le caractère par défaut ‘*’. Ce dernier peut être remplacé à l’aide de la
méthode setEchoChar(char).
Remarque : Pour des raisons de sécurité, la méthode getText() de ce composant est à éviter. Il faut
utiliser la méthode getPassword() qui retourne un tableau de caractères (char[]). En effet, il est
beaucoup plus difficile de retrouver dans la mémoire d’un programme la valeur d’un tableau de
caractère que d’une instance de type String.
…
JPasswordField myPassField = new JPasswordField();
myPassField.setEchoChar('-'); // change * by -
char[] result = myPassField.getPassword();
String result = new String(result);
…
Voici le résultat, au niveau graphique :
Machine
La valeur du champ de caractère est masquée
5.3.6. JTextArea
JTextArea est un composant semblable au JTextField, car il permet à l’utilisateur de saisir du texte.
Mais ce composant permet d’afficher plusieurs lignes de texte, alors que le JTextField ne permettait
d’en saisir qu’une seule. A l’instar de JTextField, il ne permet pas d’afficher des polices et des
couleurs de différents types. Il peut gérer le passage à la ligne et permettre de spécifier si on peut
couper un mot ou non.
L’ajout de texte dans un JTextArea peut se faire par le biais de l’utilisation de l’un des deux
constructeurs suivants :
o JTextArea (String text)
o JTextArea (String text, int rows, int columns)
Il est aussi possible d’ajouter du texte grâce aux méthodes suivantes :
o append(String text) : Ajout d’une chaîne à la fin du document
o insert(String text, int position) : Ajout d’une chaîne à une position donnée
o replaceRange(String text, int start, int end) : Remplace la chaîne contenue entre start et
end
o setText(String text) : Remplace tout le texte par la chaîne

JTextArea myField = new JTextArea(); // initialize
myField.setLineWrap(true); // start new lines automaticaly
myField.setWrapStyleWord(true); // do not cut words
Machine
Nous avons ajouté un champ texte afin de récupérer les commentaires

Le composant JTextArea est souvent utilisé avec un JScrollPane afin d’ajouter des barres de
défilement.
JTextArea myField = new JTextArea(); // initialize

jScrollPaneComment = new JScrollPane(); // initialize the scrollpane container
jScrollPaneComment.setViewportView(
getJTextArea());// add the component to its container
Grâce au JScrollPane, notre champ texte est plus simple à utiliser
Machine
5.3.7. JEditorPane
La classe JEditorPane permet d’avoir un composant graphique afin d’éditer facilement du texte à
diférents formats.
Des moteurs de rendu, implémentant l’interface EditorKit, sont proposés pour les formats :
• text/plain : affiche du texte au format texte brut
• text/html : permet d’afficher du HTML 3.2, via la classe
javax.swing.text.html.HTMLEditorKit
• text/rtf : support du format Rich Text Format.
Dans les lignes suivantes nous affichons la page principale de la documentation de java :
// …
URL url = null;
try {
url = new URL("http://java.sun.com/j2se/1.5.0/docs/index.html");
jEditorPane = new JEditorPane(url);
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
// activation html renderer
jEditorPane.setContentType("text/html");
// display the component with a horizontal and a vertical scrolling bar

JScrollPane jScrollPane = new JScrollPane();
jScrollPane.setViewportView(jEditorPane);
// …
Machine
Affichage d’une page html dans Java
5.3.8. JTextPane
Le JTextPane accepte différentes mises en forme ainsi que l’ajout d’autres composants graphiques ou
d’images, dans ce sens il s’agit d’une amélioration de composant JTextArea. JTextPane repose sur le
concept de styles définis en Java, qu’il est possible de personnaliser.
On utilise l’objet StyledDocument, qui est le modèle de ce composant, afin de définir le contenu et les
propriétés de champs style.
Voici les méthodes à employer pour ajouter d’autres composants ou des images dans votre
JTextPane :
o insertComponent(Component c) ajout d’un composant
o insertIcon(Icon i) ajout d’une image
L’intérêt de ces méthodes est donc de placer des composants comme des boutons, des labels, etc. au
sein même du champ texte.
Son utilisation étant particulièrement difficile, nous ne l’étudierons pas ici. Nous pouvons cependant
vous rediriger vers l’adresse suivante ou davantage d’exemple et d’explications sont disponibles :
http://java.sun.com/docs/books/tutorial/uiswing/components/text.html
Machine
Le champ éditable JTextPane affiche de nombreux composants
5.4. Composants proposant une liste de valeurs
5.4.1. JCheckBox
Une JCheckBox est une case à cocher, on peut ajouter un libellé à ce composant directement lors de
sa création afin de rendre plus explicite son utilisation. Il faut pour cela utiliser le constructeur
suivant : JCheckBox("Ma case a cocher").
Les JCheckBox sont utilisés lors de choix multiples que l’utilisateur doit réaliser par le biais de
l’interface.
//In initialization code:

chinButton = new JCheckBox("Chin");
chinButton.setMnemonic(KeyEvent.VK_C);
chinButton.setSelected(true);
glassesButton = new JCheckBox("Glasses");

glassesButton.setMnemonic(KeyEvent.VK_G);
glassesButton.setSelected(true);
hairButton = new JCheckBox("Hair");

hairButton.setMnemonic(KeyEvent.VK_H);
hairButton.setSelected(true);
teethButton = new JCheckBox("Teeth");

teethButton.setMnemonic(KeyEvent.VK_T);
teethButton.setSelected(true);
Machine
5.4.2. JComboBox
Ce composant représente une liste déroulante, dans laquelle l’utilisateur peut choisir un seul élément à
la fois. Il est utilisé pour présenter une liste de valeurs possibles, au sein desquelles l’utilisateur
effectue son choix. La classe JComboBox est en fait constituée d’un composant JList (étudié dans le
point suivant) et d’un JButton.
Voici la liste des différents constructeurs de cette classe :

o JComboBox() : Crée une ComboBox avec un modèle par défaut
o JComboBox(Vector) : Crée une ComboBox qui contient les éléments d’un vecteur
o JComboBox(Object[ ]) : Crée une ComboBox qui contient les éléments d’un tableau
o JComboBox(ComboBoxModel) : Crée une ComboBox qui contient les éléments d’un
modèle
Voici la liste des méthodes les plus utilisées pour ce composant :

o addActionListener(ActionListener) : Ajoute un ActionListener à la ComboBox
o addItem(Object) : Ajoute un objet à la liste
o getSelectedIndex() : Retourne l’index (int) correspondant à la sélection
o getSelectedItem() : Retourne l’objet correspondant à la sélection
o insertItemAt(Object, int) : Insère un objet à l’emplacement spécifié (index)
o paramString() : Retourne la chaîne correspondant à la sélection
o removeAllItems() : Supprime tous les objets de la ComboBox
o removeItem(Object) : Supprime un objet de la liste
o removeItemAt(int) : Supprime un objet de la liste à partir de son index
o setEditable(boolean) : Rendre éditable ou non la ComboBox
o setEnabled(boolean) : Activer / désactiver le composant
o setMaximumRowCount(int) : Définit le nombre de lignes affichables sans ascenseur
o setModel(ComboBoxModel) : Définit le modèle de données que doit utiliser la ComboBox
o setSelectedIndex(int) : Définit l’objet à sélectionner par son index (0 1er objet)
o setSelectedItem(Object) : Définit l’objet existant à sélectionner dans la ComboBox
Machine
5.4.3. JList
Le composant JList est assez similaire à JComboBox.

Le composant JComboBox est en effet basé sur un composant JList, mais il utilise un modèle de
sélection (ListSelectionModel) qui permet uniquement la sélection unique
(SINGLE_SELECTION_ONLY). Le modèle de sélection de JList supporte quant à lui trois types
de sélections dont nous parlerons dans ce chapitre.
La JList tout comme le JTree et la JTable (chapitres suivants) a la propriété d’afficher une liste de
valeurs construite à partir d’un vecteur d’objets. Les objets construits ne doivent respecter qu’une
seule contrainte, qui est d’implémenter une fonction toString(), qui retourne ce qui doit être affiché.
Voici la liste des différents constructeurs de cette classe :

o JList() Crée une JList avec un modèle par défaut
o JList(Vector) Crée une JList qui contient les éléments d’un vecteur
o JList(Object[]) Crée une JList qui contient les éléments d’un tableau
o JList(ListModel) Crée une JList qui contient les éléments d’un modèle existant
Voici la liste des méthodes les plus utilisées pour ce composant :

o getModel() Retourne le modèle associé à la liste
o setModel(ListModel) Définit le modèle associé à la liste
o setListData(Object[]) Définit les élements de la liste.
o setListData(Vector) Définit les élements de la liste.
o addListSelectionListener(ListSelectionListener) Ajoute un Listener à la liste
o setSelectedIndex(int) Définit la sélection courante par son index
o setSelectedValue(Object, boolean) Définit la sélection courante, le booléen indique
s’il faut faire défiler la liste pour afficher l’élément
o setSelectedInterval(int, int) Définit un intervalle de sélection
o getSelectedIndex() Retourne l’index de la sélection courante
o getMinSelectionIndex() Retourne l’index du 1er élément de l’intervalle
o getMaxSelectionIndex() Retourne l’index du dernier élément de l’intervalle
o getSelectedIndices() Retourne une liste d’index d’éléments sélectionnés
o getSelectedValue() Retourne l’objet correspondant à la sélection courante
o getSelectedValues() Retourne une liste d’objets correspondant aux éléments

sélectionnés
o setSelectionMode(int) Définit le mode de sélection de la liste
o getSelectionMode() Retourne le mode de sélection de la liste
Machine
o clearSelection() Désélectionne tous les éléments

o isSelectionEmpty() Retourne un booléen vérifiant : aucun élément
sélectionné
o isSelectedIndex(int) Retourne un booléen vérifiant : index i sélectionné
o ensureIndexIsVisible(int) Génère un défilement afin que l’index soit visible
o getFirstVisibleIndex() Retourne l’index du 1er élement visible
o getLastVisibleIndex() Retourne l’index du dernier élement visible
o setVisibleRowCount(int) Définit le nombre de lignes visibles
o getVisibleRowCount() Retourne le nombre de lignes visibles
Vous pouvez également personnaliser le mode de sélection. Voici les trois modes de sélection que
vous pouvez utiliser avec le composant JList :
SINGLE_SELECTION :
Un seul élément peut être sélectionné à la fois
SINGLE_INTERVAL_SELECTION :
Plusieurs éléments contigus peuvent être sélectionnés.
MULTIPLE_INTERVAL_SELECTION (par défaut) :

Toute combinaison est possible.
Voici les deux possibilités que vous avez pour modifier le mode de sélection :
JList maListe = new Jlist();
maListe.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
maListe.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
Détecter les changements de sélection

Parfois, il est nécessaire de détecter un changement de sélection. Lorsque l’on veut, par exemple,
modifier une partie de notre interface graphique, lorsqu’une ligne est sélectionnée.
Il faut, pour cela, abonner le composant JList à l’aide de la méthode :

o addListSelectionListener(ListSelectionListener)
Machine
L’interface à implémenter est donc ListSelectionListener. Cette interface ne spécifie qu’une seule
méthode à redéfinir, qui est :
o valueChanged(ListSelectionEvent e)
C’est dans cette méthode que vous pourrez spécifier l’action à effectuer lors du changement de
sélection dans votre JList.
5.4.4. JSpinner
JSpinner est un composant composé de trois sous-composants : deux petits boutons et un éditeur.
L’éditeur est par défaut un panel qui contient un champ de texte formaté (formatted text field). Les
valeurs possibles et courantes du spinner sont gérées par son modèle.
Une zone de texte, deux boutons … le JSpinner est né !
L’API Swing fournit trois modèles de spinner :

• SpinnerListModel : Les valeurs sont définies par un tableau d’objets ou une liste.
• SpinnerNumberModel : Supporte des séquences de nombres (de type double, int ou Number).
Vous pouvez spécifier les valeurs minimum et maximum, ainsi que la valeur du pas.
• SpinnerDateModel : Supporte des séquences d’objets Date. Vous pouvez spécifier les dates
minimum et maximum, ainsi que le champ (par exemple l’année) à incrémenter ou
décrémenter.
Les spinners sont similaires aux combo-boxes et aux listes dans le sens qu’ils laissent l’utilisateur
choisir une valeur dans parmi un ensemble important. Comme les combo-boxes éditables, ils
permettent généralement à l’utilisateur d’entrer une valeur. Contrairement aux combo-boxes
classiques, ils n’ont pas de liste déroulante qui peut recouvrir les autres composants.
Ils sont souvent utilisés au lieu des combo-boxes ou des listes lorsque l’ensemble des valeurs possibles
est extrêmement grand.
Cependant, les spinners doivent seulement être utilisés quand les valeurs possibles et leur séquence
sont évidentes.
5.4.5. JSlider
La classe JSlider permet d’avoir une barre de sélection (utilisée pour choisir des valeurs entières par
exemple).
Voici un exemple d’initialisation de ce composant :
static final int FPS_MIN = 0; // min value

static final int FPS_MAX = 30; // max value
static final int FPS_INIT = 15; //initial frames per second
...
JSlider framesPerSecond = new JSlider(JSlider.HORIZONTAL,
FPS_MIN, FPS_MAX, FPS_INIT);
framesPerSecond.addChangeListener(this);
//Turn on labels at major tick marks.
Machine
framesPerSecond.setMajorTickSpacing(10);
framesPerSecond.setMinorTickSpacing(1);
framesPerSecond.setPaintTicks(true);
framesPerSecond.setPaintLabels(true);
JSlider nous permet ici de définir la vitesse d’une animation graphique
5.5. Les composants de menu

5.5.1. JMenuBar
5.5.2. JPopupMenu
La classe JPopupMenu permet d’avoir un menu lors l’on réalise un clique droit dans l’application.
// À rédiger
5.5.3. JMenu
// À rédiger (voir ancien cours)
5.5.4. JMenuItem
// À rédiger (voir ancien cours)
5.5.5. JCheckBoxMenuItem
Les classes JCheckBoxMenuItem & JRadioButtonMenuItem permettent d’obtenir des menus plus
attrayants.
// À rédiger
Machine
5.5.6. JRadioButtonMenuItem
Les classes JCheckBoxMenuItem & JRadioButtonMenuItem permettent d’obtenir des menus plus
attrayants.
// À rédiger
Machine
5.6. Les composants informatifs non éditables

5.6.1. JProgressBar
La classe JProgressBar permet d’avoir une barre de progression (très utilisée pour symboliser les
temps de copie de fichiers ou de connexion).
// À rédiger
5.6.2. JToolTip
// À rédiger
Machine
5.7. Les contrôles de haut-niveau

5.7.1. JColorChooser
// À rédiger (voir ancien cours) : juste une présentation
5.7.2. JFileChooser
5.7.3. JTable
5.7.4. JTree
Machine
6. La gestion des événements

6.1. Principe
En Java, toutes les interactions de l’utilisateur se traduisent par des événements, que ce soit un clic sur
un bouton, une sélection dans un menu ou encore un simple déplacement de la souris.
Les événements en Java sont représentés par des objets qui fournissent des informations sur
l’événement lui-même et sur l’objet à l’origine de cet événement (source).
Le terme employé lorsque l’on parle de gestion des événements en Java est « Listener ».
6.2. Les classes d’événements

6.2.1. Principe
On trouve la classe java.util.EventObject à la base des classes gérant les évènements. Elle représente
la superclasse pour tous les événements.
Celle-ci fournit d’ailleurs une méthode intéressantes : getSource(). En effet, elle permet de retourner la
source de l’événement. Cet objet source pourra être alors casté dans son type d’origine.
Un événement est capable d’encapsuler des informations concernant son contexte d’apparition :
o Le composant source de l’événement.
o Les coordonnées du clic (dans le cas d’un MouseEvent).
o La valeur de la touche tapée pour un KeyEvent.
o …
L’objet qui intercepte l’interaction utilisateur est appelé un Listener. Comme ce nom l’indique, son
rôle principal est d’être « à l’écoute » d’un composant (JButton, JPanel…).
Le Listener doit s’abonner à l’événement auprès du composant. Il demande ainsi au composant de
l’avertir en cas d’interaction utilisateur sur ce composant.
Abonnement
Bouton Listener
Notification
Machine
Le principe de la gestion des événements
C’est au niveau du composant que l’on trouve les méthodes d’abonnement aux différents Listeners.
Ces méthodes s’expriment sous la forme addXxxListener(XxxListener l) où Xxx représente le type
d’événement écouté.
Exemples de méthodes d’abonnement :

o addActionListener()
o addKeyListener()
o addFocusListener()
o …
Par ailleurs, ces méthodes sont héritées de la classe Container et sont donc communes à un grand
nombre de composants et conteneurs.
On utilise la plupart du temps l’interface ActionListener, qui l’on implémente à sa guise, pour gérer
les évènements.
Il est aussi possible de désabonner un Listener du composant auquel il a été abonné, à l’aide de la
méthode removeXxxListener() ou Xxx doit être remplacé par le nom de l’événement.
6.3. Utilisation
6.4. Évènements spécifiques

6.4.1. Evénements de java.awt.event
ActionEvent : Evénement généré si on active un bouton (via le clavier ou la souris), si on double

clique sur un élément de liste ou si on sélectionne un élément de menu.
String getActionCommand() retourne le nom de la commande associée à un événement.

(dans le cas d’un bouton sans action command, retourne
son libellé)
ComponentEvent : Evènement généré lorsqu’un élément est caché, déplacé, redimensionné, ou

lorsqu’il apparaît.
Component getComponent() renvoie l’objet à l’origine de l’événement (le cast peut

être necessaire)
Machine
ContainerEvent : Evènement généré lorsqu’un élément est ajouté ou supprimé d’un container.
Container getContainer() renvoie une référence au container à l’origine de

l’événement
Component getChild() renvoie une référence à l’élément ajouté au container ou
supprimé
FocusEvent : Evènement généré lorsqu’un élément gagne ou perd le focus.
boolean isTemporary() true si l’événement est temporaire et false dans le cas

contraire
Une zone de texte perd temporairement le focus si
l’utilisateur manipule l’ascenceur pendant la saisie
KeyEvent : Evènement généré lorsqu’une touche du clavier est pressée.
char getKeyChar() retourne le caractère saisi

int getKeyCode() retourne le code de la touche pressée
… + nombreuses autres méthodes
MouseEvent : Evènement généré lorsque l’on déplace la souris, lorsqu’on la fait glisser (drag), lors du
clic ou du relâchement d’un bouton.
int getX() retourne la position horizontale du pointeur

int getY() retourne la position verticale du pointeur
Point getPoint() retourne les coordonnées du pointeur de la souris dans un objet
java.awt.Point
int getClickCount() retourne le nombre de clics effrectués lors de l’événement
6.4.2. Evénements de javax.swing.event
o TreeSelectionEvent – Changement de la position courante dans un JTree

o HyperlinkEvent – Clic sur un lien hypertexte
o JInternalFrameEvent – Support des évènements ayant pour source une JInternalFrame
o ListSelectionEvent – Changement dans la sélection
o …
6.5. Les listeners d’événements
Les Listeners sont créés par l’implémentation d’une (ou de plusieurs) interface(s) fournie(s) par le
package java.awt.event. Lorsque l’événement survient, la source appelle la méthode des Listener qui
se sont abonnés à l’évènement.
L’implémentation d’une interface impose donc de redéfinir une (ou plusieurs) méthode(s)
obligatoire(s). De plus, des objets, nommés « Adapter », fournissent une implémentation par défaut
où toutes les méthodes ont un corps vide. Ces objets là sont en réalité des classes, et non des
Machine
interfaces. Le développeur n’a plus à implémenter toutes les méthodes de l’interface, ce qui peut-être
fastidieux.
Ils se mettent à l’écoute d’un composant qui s’abonne auprès d’eux et intercepte tous les événements,
et selon leur nature va réagir en conséquence en exécutant la méthode cible de l’évènement.
L’abonnement se fait par le biais des méthodes addXxxListener(), où Xxx représentent le type
d’événement. Les Listeners les plus communs sont illustrés brièvement ici. Un tableau général fait état
de l’ensemble des Listeners avec les méthodes à implémenter :
ActionListener : Définit la méthode pour intercepter les événements d’actions.

Il est utilisé le plus souvent lors des cliques sur un bouton par exemple. Le fait d’implémenter ce
Listener vous imposera de redéfinir la méthode actionPerformed(ActionEvent).
void actionPerformed(ActionEvent ae)
ComponentListener : Définit le comportement à adopter quand un élément graphique est caché,

déplacé, redimensionné ou affiché.
void componentHidden(ComponentEvent ce)

void componentMoved(ComponentEvent ce)
void componentResized(ComponentEvent ce)
void componentShown(ComponentEvent ce)
ContainerListener : Définit le comportement à adopter quand un élément graphique est ajouté ou

supprimé d’un container.
void componentAdded(ContainerEvent ce)

void componentRemoved(ContainerEvent ce)
FocusListener : Définit le comportement à adopter quand un élément graphique a obtenu ou perdu le

focus.
Il est utilisé lorsqu’un composant graphique reçoit ou perd le focus. Le fait d’implémenter ce Listener
vous imposera de redéfinir les méthodes focusGained(FocusEvent) et focusLost(FocusEvent). Vous
pouvez également hériter de la classe FocusAdapter au lieu d’utiliser le principe de l’implémentation.
void focusGained(FocusEvent fe)

void focusLost(FocusEvent fe)
ItemListener peut être utilisé sur plusieurs composants différents. Le plus souvent il est mis en action
lors d’une sélection dans une JComboBox afin de prendre en compte l’élément sélectionné de
manière le plus dynamique possible en redéfinissant la méthode itemStateChanged(ItemEvent).
ListSelectionListener est utilisé avec le composant JList pour gérer les évènements liés à la sélection
de valeur dans ce composant en redéfinissant la méthode valueChanged(ListSelectionEvent).
o Listener relatifs à la sourie et au clavier
KeyListener : Définit le comportement à adopter quand une touche est appuyée, relâchée ou si une
lettre a été tapée.
Machine
Ex : Touche c appuyée → appel successif des 3 méthodes.

Ex : Touche Shift appuyée → appel successif des 2 premières méthodes uniquement
void keyPressed(KeyEvent ke)

void keyReleased(KeyEvent ke)
void keyTyped(KeyEvent ke)
KeyListener est utilisé sur les composants qui permettent à l’utilisateur de saisir du texte, JTextField,
JPasswordField, …
MouseListener : Définit le comportement à adopter quand on clique avec la souris, appuie sur un
bouton, relâche un bouton, si le pointeur de la souris entre ou sort de la zone d’un élément graphique.
void mouseClicked(MouseEvent me)

void mouseEntered(MouseEvent me)
MouseListener est un Listener, comme le suivant qui peut être employé sur beaucoup de composants
différents. Vous pouvez par exemple prendre en compte le clic sur un JLabel contenant une image. Le
fait d’implémenter ce Listener vous imposera de redéfinir les méthodes :
mouseClicked(MouseEvent), mouseEntered(MouseEvent), mouseExited(MouseEvent),
mousePressed(MouseEvent), mouseReleased(MouseEvent) ou vous pouvez hériter de la classe
MouseAdapter au lieu d’utiliser le principe de l’implémentation.
MouseMotionListener est un Listener très semblable au précédent, cependant celui-ci vous permettra
de gérer l’action de drag & drop. Le fait d’implémenter ce Listener vous imposera de redéfinir les
méthodes : mouseDragged(MouseEvent), mouseMoved(MouseEvent). Si vous ne souhaitez pas
redéfinir les deux méthodes mais uniquement une seule d’entre elles, vous pouvez hériter de la classe
MouseMotionAdapter au lieu d’utiliser le principe de l’implémentation.
Machine
7. Utilisation des “modèles”
Machine
8. Autres fonctionnalités
8.1. Le look-and-feel
On dit que Swing propose une architecture « pluggable look-and-feel ». Ce terme signifie que
l’application peut contrôler l’apparence (look) et le comportement (feel) de son interface graphique.
Ainsi, une application Swing peut émuler l’apparence et le comportement de la plateforme, ou s’en
affranchir et proposer une apparence et un comportement propre et identique d’une plateforme
d’exécution à une autre. De plus, le développeur peut implémenter du code permettant de modifier le
look-and-feel de l’application dynamiquement.
Voici un exemple des différents « look & feel » disponibles avec Java 5:
Sous MacOs X
Sous Windows
Machine
Sous Linux (GTK)
Si vous portez une attention particulière à cette fonctionnalitée, qui est hautement personnalisable,
vous trouverez des compléments d’information à ces adresses :
http://java.sun.com/docs/books/tutorial/uiswing/misc/plaf.html
http://www.jgoodies.com/index.html
http://java.developpez.com/faq/java/?page=generalitesAWTSwing - lf (français)
8.2. Le mode de distribution d’applications Java
Afin d’assurer la portabilité des applications Java, il n’y a pas de possibilité (en standard) de créer des
fichiers exécutables (.exe). Cependant, il est posssible de créer des fichiers JAR, qui sont des fichiers
archives (Java ARchive). C’est une manière de distribuer les applications Java. Ce type de fichier se
comporte comme un fichier exécutable, il est donc aussi simple d’utilisation.
Il est possible de créer un fichier JAR en ligne de commande :
jar cfm jarfile inputfiles
Quelques options pour la commande jar :
o L’option ‘c’ indique que vous souhaitez créer un fichier JAR
o L’option ‘f’ permet de spécifier le nom du fichier d’archive (c’est dans ce fichier que l’on va
diriger l’archive plutôt que dans la sortie standard).
o L’option ‘m’ permet de spécifier le fichier manifest qui va contenir différentes informations
pour la création de l’archive (notamment l’indication de la classe contenant la méthode main)
o jarfile est le nom du fichier JAR que vous voulez créer, par convention le fichier a une
extension .jar.
o inputfiles regroupe l’ensemble des fichiers contenus dans le fichier JAR que vous voulez
créer. Les noms de fichiers à inclure sont séparés par un espace. Si le nom de fichier est un
répertoire, son contenu est ajouté de manière récursive.
Machine
Exemple :
jar cfm NomDuJar.jar monManifest.mf MaClass1.class MaClass2.class
L’ordre des options n’a pas d’importance, mais il ne doit pas y avoir d’espace entre chacune des
options. Par ailleurs, si l’option ‘f’ est située avant l’option ‘m’, alors le nom du fichier JAR devra
être placé avant le nom du manifest, et inversement.
Cette commande génèrera un fichier JAR compressé dans le répertoire courant. Cette commande
génèrera aussi le fichier manifest monManifest.mf dans le fichier JAR à partir des informations
données.
Ce fichier se situe dans le répertoire /META-INF du fichier JAR et se nomme MANIFEST.MF. C’est
un descripteur du contenu de votre fichier JAR, et c’est grâce à ce fichier que votre JAR sera auto-
exécutable.
Voici un exemple de contenu d’un fichier manifest :
Manifest-Version: 1.0
Main-Class: monpackage.MaClasse
Vous pouvez aussi utiliser un IDE (Integrated Development Environment) pour automatiser
toute la génération de votre fichier JAR. Avec Eclipse, un assistant est disponible.
8.3. Chargements des ressources situées dans un Jar

Comme nous venons de le voir, lorsque l’on déploie une application on utilise le format jar pour y
stocker le bytecode mais également les ressources (images, fichiers textes, …). Ainsi, afin de pouvoir
être sûr d’accéder à celles-ci, que l’application soit sous forme de jar ou pas, il est nécessaire d’utiliser
le ClassLoader. En effet, il se base sur le « classpath 1» et non au système de fichier.
Il existe deux façon de l’appeler :
URL myResourceURL =
this.getClass().getResource("/myPic.jpg"));
ClassLoader loader = Thread.currentThread().getContextClassLoader();

URL url =
loader.getResource("myPic.jpg");
La deuxième est utilisée dans des méthodes statique, car il n’est pas possible d’avoir accès au pointeur
this dans ce cas précis.
Remarque : lorsque l’on utilise le second exemple, il ne faut pas faire précéder le chemin vers la
ressource d’un « / ».
1
Le classpath est un zone mémoire dans la machine virtuel qui, au lancement d’une
application, liste toutes les classes et les ressources à disposition. Pas défaut, il s’agit du
répertoire courant ainsi que les librairies installées avec la JRE. On peut le configurer avec la
variable d’environnement CLASSPATH.
Machine
8.4. Java Web Start

Il s’agit d’un outil permettant de mettre à disposition une application à partir d’internet. Il faut au
préalable que l’application soit disponible sous forme de jar (sujet traité dans les pages précédentes).
Ensuite nous allons écrire, et surtout commenter, un fichier de déploiement avec l’extension « .jnlp ».
Voici par exemple celui d’une application servant de démonstration :





<jnlp
spec="1.5+"
codebase="http://10.1.77.3/tetris"
href="demo_tetris.jnlp">
<information>


<title>Sun laboratory - Demo Tetris</title>


<vendor>Supinfo</vendor>

<homepage href="."/>


<description>This is a pleasant game !</description>
<description kind="short">
This application is an educational-purpose tetris-like.
</description>


<icon href="demo_tetris.gif"/>




<icon kind="splash" href="demo_tetris.gif"/>




<offline-allowed/>


<shortcut
online="false">
<desktop/>
<menu submenu="Sun Laboratory Applications"/>
</shortcut>
</information>

<security>

<all-permissions/>
Machine
</security>



<resources>
<j2se version="1.5.0+" java-vm-args="-esa -Xnoclassgc"/>
<jar href="tetris.jar"/>
<jar href="lib/derby.jar"/>
<jar href="lib/derbyclient.jar"/>
<jar href="lib/derbynet.jar"/>
<jar href="lib/derbytools.jar"/>
</resources>




<application-desc />
</jnlp>
Pour plus d’information, notamment pour signer une application :

http://java.sun.com/j2se/1.5.0/docs/guide/javaws/index.html
8.5. Internationalisation (I18N)

Java fournit des classes permettant de pouvoir changer la langue de l’application. Nous utilisons tout
dabord des fichiers de propriété pour chacune d’entre elles :
lang_fr.properties : fichier pour la langue française

lang_zh.properties : fichier pour la langue chinoise
lang.properties : fichier pour la langue par défaut (généralement réservée à l’anglais)
Dans notre application, nous devrons appeler la méthode statique suivante :
buttonEnglish.setText(
java.util.ResourceBundle.getBundle("lang").getString("English"));
La langue par défaut est celle utilisée par le système d’exploitation. Cependant, si l’on souhaite la
modifier dans notre application nous pouvons utiliser :
Locale.setDefault(Locale.FRENCH);
Machine
9. Conclusion
Dans ce cours nous avons parcouru les éléments essentiels de Swing, afin de pouvoir concevoir une
interface graphique fonctionnelle et ayant le minimum de composant.
Nous approfondirons nos connaissances dans le cours « Swing Avancé » en abordant des composants
de haut-niveau, aussi que certains éléments d’architecture.
Pour plus d’informations sur certains composants, n’hésitez pas à consulter également le site
http://java.sun.com/docs/books/tutorial/uiswing/index.html qui fournit de nombreuses explications sur
la plupart des composants.
Un livre, ayant déjà quelques années mais toujours d’actualité, est disponible à l’adresse suivante :
http://java.sun.com/products/jlf/ed2/book/.

05 - Labo Sun - Cours - Swing Base - 4.0

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

05 - Labo Sun - Cours - Swing Base - 4.0

Încărcat de

Drepturi de autor:

Formate disponibile

http://www.labo-sun.

Les bases de Swing

Auteur : Maxime Vialette

Ecole Supérieure d’Informatique de Paris

Table des matières

5.4. COMPOSANTS PROPOSANT UNE LISTE DE VALEURS ................................................................................. 41

2. Les Java Foundation Classes

2.1. API AWT

2.2. API Swing

2.3. API Java2D

2.4. Drag & Drop

2.5. API Accessibility & Internationalization

L’API Internationalization permet au développeur de créer des applications multilingues qui

3. Fonctionnement d’une application

3.1. Architecture globale

- La fenêtre, du type JFrame

3.2. Écriture de l’application

3.2.1. Création de la classe

// import awt and swing objects

public class TravelMonth extends JFrame {

Nous allons par la suite écrire le code de cette classe.

3.2.2. Déclaration des composants graphiques

// root container of the JFrame

// enclose some jlabels

// display text informations

private JLabel jLabel = null;

3.2.3. Initialisation de l’interface graphique

// define the default operation when

// define which panel is the root panel

// define the title of the frame

3.2.4. Définir le conteneur racine

Le conteneur correspond à la variable « jContentPane ». Nous allons l’instancier dans la méthode

// create an instance of JPanel

// display the following phrase "Travels during this month : "

// dispose a panel at the center of the frame

// the jPanel variable contains the

// add the labels to the jPanel

3.2.5. Lancement de l’application

La méthode main(…) sert de point d’entrée dans notre application.

// a JFrame is not visible by default

4. Les composants Swing

- Les composants de haut niveau : les fenêtres (JFrame, JDialog, etc.)

4.1. Les conteneurs de haut niveau

Ci-dessous, nous allons présenter les principales méthodes de la classe JFrame.

Méthodes utiles de la classe JFrame :

4.1.2. Le conteneur JDialog

Voici les différents constructeurs auxquels vous avez accès :

Voici un exemple d’utilisation :

Il est à noter qu’une boîte de dialogue JOptionPane est modale.

JOptionPane.showConfirmDialog(null, "Voulez vous quitter l'application",

Object[] options = {"ACCEPTER", "REFUSER"};

JOptionPane.showOptionDialog(null, "Les valeurs doivent elles êtres définitivement

String inputValue = JOptionPane.showInputDialog("Entrez une valeur");

Object[] possibleValues = {"France", "Royaume-Uni", "Allemagne", "Irlande",

4.1.3. Méthodes showXxxDialog

showConfirmDialog(Component Parent, Object Message, String title, int optionType,

showInputDialog(Component Parent, Object message)

Crée une boîte de dialogue de saisie

showMessageDialog(Component Parent, Object message)

Crée une boîte de dialogue affichant un message

showOptionDialog(Component Parent, Object message, String title, int optionType,

Les constantes associées sont les suivantes :

messageType : définit le style de message

optionType : définit le type de boutons d’options qui apparaissent en bas de la boîte de