Académique Documents
Professionnel Documents
Culture Documents
com
labo-sun@supinfo.com
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 3 / 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
Les bases de Swing – Interface Homme- 4 / 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
Les bases de Swing – Interface Homme- 5 / 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é.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 6 / 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
Les bases de Swing – Interface Homme- 7 / 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
Les bases de Swing – Interface Homme- 8 / 61
Machine
Dans l’interface utilisateur que nous voyons ci-dessus, nous pouvons dénombrer des conteneurs :
Les composants que l’on affiche sont des champs de texte, mais il en existe beaucoup d’autres
(boutons, listes déroulantes, etc.).
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 9 / 61
Machine
Nous allons créer une classe nommée TravelMonth, située dans le package
com.labosun.swing.exercise1 :
package com.labosun.swing.exercise1;
…
}
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;
Dans un premier temps, le constructeur initialise la fenêtre, de type JFrame, et ici représentée par le
mot clé this.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 10 / 61
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);
La méthode getJPanel() n’a pas encore été vue. Voici son contenu :
/**
* This method initializes jPanel
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 11 / 61
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();
/**
* This is the entry point of the application
*
* @param args
*/
public static void main(String[] args){
TravelMonth exercice = new TravelMonth();
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 12 / 61
Machine
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 :
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 13 / 61
Machine
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 14 / 61
Machine
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.
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.
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)
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 15 / 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
Les bases de Swing – Interface Homme- 16 / 61
Machine
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)
Cette méthode permet de personnaliser les icônes affichées et le groupe de boutons associés
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 17 / 61
Machine
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)
• ERROR_MESSAGE
• INFORMATION_MESSAGE
• WARNING_MESSAGE
• QUESTION_MESSAGE
• PLAIN_MESSAGE
• DEFAULT_OPTION
• YES_NO_OPTION
• YES_NO_CANCEL_OPTION
• OK_CANCEL_OPTION
• YES_OPTION
• NO_OPTION
• CANCEL_OPTION
• OK_OPTION
• CLOSED_OPTION
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 18 / 61
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.
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.
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.
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 19 / 61
Machine
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.
myFrame.getContentPane().add(p1);
myFrame.getContentPane().add(p2);
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 20 / 61
Machine
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.
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 21 / 61
Machine
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)
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 22 / 61
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
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);
…
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 23 / 61
Machine
Une instance de JRootPane est créée automatiquement par la JFrame lorsque son constructeur fait
appel à la méthode createRootPane().
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.
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, …).
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 24 / 61
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.
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 JFrame
• setJMenuBar(JMenuBar menu) Méthode pour transmettre une barre de
menus à JFrame.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 25 / 61
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 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é.
Point point;
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 26 / 61
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.
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);
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 27 / 61
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.
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.
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 28 / 61
Machine
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 29 / 61
Machine
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 30 / 61
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)
• ActionListener[] getActionListeners()
• void removeActionListener(ActionListener l)
• void doClick()
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)
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 31 / 61
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.
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é).
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 32 / 61
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><font color='red'>Mario Bros</font></html>");
// this one is selected by default
buttonMario.setSelected(true);
// sonic choice
JRadioButton buttonSonic =
new JRadioButton(
"<html><font color='blue'>Sonic the hedgehog</font></html>");
// warcraft choice
JRadioButton buttonWarcraft =
new JRadioButton(
"<html><font color='green'>Warcraft</font></html>");
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 33 / 61
Machine
Nous avons pu remarquer également la syntaxe HTML que nous venons d’utiliser pour spécifier les
couleurs des zones de texte.
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.
…
jLabel = new JLabel();
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 34 / 61
Machine
jLabel.setText("JLabel");
…
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("");
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 35 / 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
Les bases de Swing – Interface Homme- 36 / 61
Machine
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
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);
…
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 37 / 61
Machine
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 38 / 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
Les bases de Swing – Interface Homme- 39 / 61
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");
// …
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 40 / 61
Machine
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 41 / 61
Machine
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 42 / 61
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 43 / 61
Machine
5.4.3. JList
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 44 / 61
Machine
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.
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);
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 45 / 61
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.
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).
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 46 / 61
Machine
framesPerSecond.setMajorTickSpacing(10);
framesPerSecond.setMinorTickSpacing(1);
framesPerSecond.setPaintTicks(true);
framesPerSecond.setPaintLabels(true);
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
5.5.4. JMenuItem
5.5.5. JCheckBoxMenuItem
Les classes JCheckBoxMenuItem & JRadioButtonMenuItem permettent d’obtenir des menus plus
attrayants.
// À rédiger
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 47 / 61
Machine
5.5.6. JRadioButtonMenuItem
Les classes JCheckBoxMenuItem & JRadioButtonMenuItem permettent d’obtenir des menus plus
attrayants.
// À rédiger
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 48 / 61
Machine
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 49 / 61
Machine
5.7.2. JFileChooser
5.7.3. JTable
5.7.4. JTree
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 50 / 61
Machine
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 ».
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 51 / 61
Machine
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é.
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 52 / 61
Machine
ContainerEvent : Evènement généré lorsqu’un élément est ajouté ou supprimé d’un container.
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.
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 53 / 61
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 :
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).
KeyListener : Définit le comportement à adopter quand une touche est appuyée, relâchée ou si une
lettre a été tapée.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 54 / 61
Machine
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.
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 55 / 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
Les bases de Swing – Interface Homme- 56 / 61
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
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 57 / 61
Machine
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)
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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 58 / 61
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.
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.
URL myResourceURL =
this.getClass().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.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 59 / 61
Machine
<!-- Contains the URL locating the home page for the Application. -->
<homepage href="."/>
<!-- Contains an HTTP URL to an image file in either GIF or JPEG format. -->
<!-- The icons are used to represents the application -->
<icon href="demo_tetris.gif"/>
<!-- shortcut element: The optional shortcut element can be used to -->
<!-- indicate an application's preferences for desktop integration. -->
<shortcut
online="false">
<desktop/>
<menu submenu="Sun Laboratory Applications"/>
</shortcut>
</information>
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 60 / 61
Machine
</security>
<!-- The resources element is used to specify all the resources, such as -->
<!-- Java class files, native libraries, and system properties, -->
<!-- that are part of the application. -->
<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>
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);
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs
Les bases de Swing – Interface Homme- 61 / 61
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/.
http://www.labo-sun.com
Ce document est la propriété de Supinfo et est soumis aux règles de droits d’auteurs