14.4. Les composants Swing

14. Le développement d'interfaces graphiques avec
SWING
Swing fait partie de la bibliothèque Java Foundation Classes (JFC). C'est une API dont le but
est similaire à celui de l'API AWT mais dont le mode de fonctionnement et d'utilisation est
conplètement différent. Swing a été intégrée au JDK depuis sa version 1.2. Cette bibliothèque
existe séparement pour le JDK 1.1.
La bibliothèque JFC contient :
 l'API Swing : de nouvelles classes et interfaces pour construire des interfaces
graphiques
 Accessibility API :
 2D API: support du graphisme en 2D
 API pour l'impression et le cliquer/glisser
Ce chapitre contient plusieurs sections :
 Présentation de Swing
 Les packages Swing
 Un exemple de fenêtre autonome
 Les composants Swing
 Les boutons
 Les composants de saisie de texte
 Les onglets
14.1. Présentation de Swing
Swing propose de nombreux composants dont certains possèdent des fonctions étendues, une
utilisation des mécanismes de gestion d'événements performants (ceux introduits par le JDK
1.1) et une apparence modifiable à la volée (une interface graphique qui emploie le style du
système d'exploitation Windows ou Motif ou un nouveau style spécifique à Java nommé
Metal).
Tous les éléments de Swing font partie d'un package qui a changé plusieurs fois de nom : le
nom du package dépend de la version du J.D.K. utilisée :
 com.sun.java.swing : jusqu'à la version 1.1 beta 2 de Swing, de la version 1.1 des JFC
et de la version 1.2 beta 4 du J.D.K.
 java.awt.swing : utilisé par le J.D.K. 1.2 beta 2 et 3
 javax.swing : à partir des versions de Swing 1.1 beta 3 et J.D.K. 1.2 RC1
Les composants Swing forment un nouvelle hériarchie parallèle à celle de l'AWT. L'ancêtre
de cette hiérarchie est le composant JComponent. Presque tous ces composants sont écrits en

pur Java : ils ne possèdent aucune partie native sauf ceux qui assurent l'interface avec le
système d'exploitation : JApplet, JDialog, JFrame, et JWindow. Cela permet aux composants
de toujours avoir la même apparence quelque soit le système sur lequel l'application s'exécute.
Tous les composants Swing possèdent les caractéristiques suivantes :
 ce sont des beans
 ce sont des composants légers (pas de partie native) hormis quelques exceptions.
 leurs bords peuvent être changés
La procédure à suivre pour utiliser un composant Swing est identique à celle des composants
de la bibliothèque AWT : créer le composant en appelant son constructeur, appeler les
méthodes du composant si nécessaire pour le personnaliser et l'ajouter dans un conteneur.
Swing utilise la même infrastructure de classes que AWT, ce qui permet de mélanger des
composants Swing et AWT dans la même interface. Sun recommande toutefois d'éviter de les
mélanger car certains peuvent ne pas être restitués correctement.
Les composants Swing utilisent des modèles pour contenir leurs états ou leur données. Ces
modèles sont des classes particulières qui possèdent toutes un comportement par défaut.
14.2. Les packages Swing
Swing contient plusieurs packages :
javax.swing
package principal : il contient les interfaces, les
principaux composants, les modèles par défaut
javax.swing.border
Classes représentant les bordures
javax.swing.colorchooser
Classes définissant un composant pour la sélection de
couleurs
javax.swing.event
Classes et interfaces pour les événements spécifiques à
Swing. Les autres événements sont ceux de AWT
(java.awt.event)
javax.swing.filechooser
Classes définissant un composant pour la sélection de
fichiers
javax.swing.plaf
Classes et interfaces génériques pour gérer l'apparence
javax.swing.plaf.basic
Classes et interfaces de base pour gérer l'apparence
javax.swing.plaf.metal
Classes et interfaces pour définir l'apparence Metal qui
est l'apparence par défaut
javax.swing.table
Classes définissant un composant pour la présentation
de données sous forme de tableau
javax.swing.text
Classes et interfaces de bases pour les composants
manipulant du texte
javax.swing.text.html
Classes permettant le support du format HTML
javax.swing.text.html.parser
Classes permettant d'analyser des données au format

HTML
javax.swing.text.rtf
Classes permettant le support du format RTF
javax.swing.tree
Classes définissant un composant pour la présentation
de données sous forme d'arbre
javax.swing.undo
Classes permettant d'implémenter les fonctions
annuler/refaire
14.3. Un exemple de fenêtre autonome
La classe de base d'une application est la classe JFrame. Son rôle est équivalent à la classe
Frame de l'AWT et elle s'utilise de la même façon.
Exemple ( code Java 1.1 ) :
import javax.swing.*;
import java.awt.event.*;
public class swing1 extends JFrame {
public swing1() {
super("titre de l'application");
WindowListener l = new WindowAdapter() {
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
addWindowListener(l);
setSize(200,100);
setVisible(true);
}
public static void main(String [] args){
JFrame frame = new swing1();
}
}
14.4. Les composants Swing
Il existe des composants Swing équivalents pour chacun des composants AWT avec des
constructeurs semblables. De nombreux constructeurs acceptent comme argument un objet de
type Icon, qui représente une petite image généralement stockée au format Gif.
Le constructeur d'un objet Icon admet comme seul paramètre le nom ou l'URL d'un fichier
graphique
Exemple ( code Java 1.1 ) :
import javax.swing.*;
import java.awt.event.*;
public class swing3 extends JFrame {
public swing3() {

super("titre de l'application");
WindowListener l = new WindowAdapter() {
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
addWindowListener(l);
ImageIcon img = new ImageIcon("tips.gif");
JButton bouton = new JButton("Mon bouton",img);
JPanel panneau = new JPanel();
panneau.add(bouton);
setContentPane(panneau);
setSize(200,100);
setVisible(true);
}
public static void main(String [] args){
JFrame frame = new swing3();
}
}
14.4.1. La classe JFrame
JFrame est l'équivalent de la classe Frame de l'AWT : les principales différences sont
l'utilisation du double buffering qui améliore les rafraichissements et l'utilisation d'un panneau
de contenu (contentPane) pour insérer des composants (ils ne sont plus insérés directement au
JFrame mais à l'objet contentPane qui lui est associé). Elle représente une fenêtre principale
qui possède un titre, une taille modifiable et éventuellement un menu.
La classe possède plusieurs constructeurs :
Constructeur
Rôle
JFrame()
JFrame(String)
Création d'une instance en précisant le titre
Par défaut, la fenêtre créée n'est pas visible. La méthode setVisible() permet de l'afficher.
Exemple ( code Java 1.1 ) :
import javax.swing.*;
public class TestJFrame1 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300,100);
f.setVisible(true);
}
}
La gestion des événements est identique à celle utilisée dans l'AWT depuis le J.D.K. 1.1.
Exemple ( code Java 1.1 ) :
import javax.swing.*;

import java.awt.event.*;
public class swing2 extends JFrame {
public swing2() {
super("titre de l'application");
WindowListener l = new WindowAdapter() {
public void windowClosing(WindowEvent e){
System.exit(0);
}
};
addWindowListener(l);
JButton bouton = new JButton("Mon bouton");
JPanel panneau = new JPanel();
panneau.add(bouton);
setContentPane(panneau);
setSize(200,100);
setVisible(true);
}
public static void main(String [] args){
JFrame frame = new swing2();
}
}
Tous les composants associés à un objet JFrame sont gérés par un objet de la classe
JRootPane. Un objet JRootPane contient plusieurs Panes. Tous les composants ajoutés au
JFame doivent être ajoutés à un des Pane du JRootPane et non au JFrame directement. C'est
aussi à un de ces Panes qu'il faut associer un layout manager si nécessaire.
Le Pane le plus utilisé est le ContentPane. Le Layout manager par défaut du contentPane est
BorderLayout. Il est possible de le changer :
Exemple ( code Java 1.1 ) :
...
f.getContentPane().setLayout(new FlowLayout());
...
Exemple ( code Java 1.1 ) :
import javax.swing.*;
public class TestJFrame2 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300,100);
JButton b =new JButton("Mon bouton");
f.getContentPane().add(b);
f.setVisible(true);
}
}
Le JRootPane se compose de plusieurs éléments :