import javax.swing. - mekidiche mohamed bouhlou

Interfaces graphiques avec Swing
Badr Benmammar
[email protected]
Plan
 Différences entre AWT et Swing
 Swing et MVC (Modèle-Vue-Contrôleur)
 Composants SWING
 JFrame
 JLabel
 JButton
 JCheckBox
…
 JPanel
 JMenu
Swing
 Swing fait partie de la bibliothèque Java Foundation Classes (JFC).
 JFC est un framework graphique pour Java composé de AWT, Swing et Java2D.
 C’est une API dont le but est similaire à celui de l’API AWT mais dont le mode
de fonctionnement et d’utilisation est complètement différent.
 Swing a été intégré au JDK depuis sa version 1.2.
 Cette bibliothèque existe séparément pour le JDK 1.1.
 La librairie AWT a été développée pour la première sortie de Java version 1.0 du jdk.
 Swing n’est apparue qu’à la version 1.2 du jdk (soit Java 2), il en résulte donc des
différences fondamentales de conception entre les deux librairies.
Différences entre AWT et Swing
 Composant AWT : un composant AWT lors de sa création est associé à une fenêtre
distincte (un homologue, peer en anglais) gérée par le système d’exploitation sousjacent.
 C’est cet homologue qui est responsable de son apparence.
 Cette "manière" de faire, bien qu’elle ait fait ses preuves et qu’elle ait permis au
langage Java de s’imposer, est très lourde (perte de performance, et consommation
excessive de mémoire).
 C’est pour cette raison que l’on qualifie les composants AWT par heavyweight
(poids lourds).
Différences entre AWT et Swing
 Composant Swing : par opposition, les composants Swing sont simplement dessinés
à l’intérieur de leur conteneur comme s’il s’agissait d’une image, et aucun homologue
du système sous jacent ne leur est affecté.
 C’est pourquoi ils sont qualifiés de lightweight (composants allégés).
 Swing possède bien d'autres avantages :

La gestion de bordure, les info-bulles, le défilement, les Look And Feel, de
nouveaux LayoutManager, ainsi que l’architecture MVC (Model-ViewControl).
Différences entre AWT et Swing
 Les composants AWT restaient liés à la plate-forme locale, car écrits en code natif, ce
qui provoquait des différences d'apparence.
 Java Native Interface (JNI) est un framework qui permet à du code Java
s'exécutant à l'intérieur de la JVM d'appeler et d'être appelé par des applications
natives (c'est-à-dire des programmes spécifiques au matériel et au système
d'exploitation de la plate-forme concernée), ou avec des bibliothèques logicielles
basées sur d'autres langages (C, C++, assembleur, etc.).
 Les composants Swing, sont écrits en Java, ce qui leur confère plus de souplesse et
d'adaptabilité.
Différences entre AWT et Swing
 Les composants de type fenêtre, comme JFrame, restent forcément dépendants du
système.
 On peut d'abord distinguer ces nouveaux composants car leur nom commence par J.
 Classe bouton est nommée Button en AWT, et JButton en SWING.
 Les paquetages à importer sont qualifiés par javax.swing au lieu de java.awt
 Au point de vue héritage, les classes des composants swing étendent les fonctionnalités
des classes des composants awt analogues.
Différences entre AWT et Swing
 Exemple : Filiation de JFrame :
java.lang.Object
java.awt.Component
java.awt.Container
java.awt.Window
java.awt.Frame
javax.swing.JFrame
 Le paquetage javax.swing contient la classe JApplet ; il n'y a plus besoin d'importer
java.applet.
 import javax.swing.JApplet à la place de import java.applet.Applet
Modèle-Vue-Contrôleur
 Modèle-Vue-Contrôleur (en abrégé MVC, de l’anglais Model-View-Controller) est une
architecture et une méthode de conception qui organise l’interface homme-machine
(IHM) d’une application logicielle.
 Ce paradigme divise l’IHM en un modèle (modèle de données), une vue (présentation,
interface utilisateur) et un contrôleur (logique de contrôle, gestion des événements,
synchronisation), chacun ayant un rôle précis dans l’interface.
 L’organisation globale d’une interface graphique est souvent délicate.
 L’architecture MVC ne résout pas tous les problèmes.
 Elle fournit souvent une première approche qui peut ensuite être adaptée.
 Elle offre aussi un cadre pour structurer une application.
Modèle-Vue-Contrôleur
 Ce modèle d’architecture impose la séparation entre :
 Données
 Présentation
 Traitements
 Cette séparation donne trois parties fondamentales dans l’application finale :
 Modèle
 Vue
 Contrôleur
 Swing utilise le principe Modèle-Vue-Contrôleur (les composants Swing jouent en
fait le rôle du contrôleur au sens du MVC) et dispose de plusieurs choix d’apparence
(de vue) pour chacun des composants standards.
Modèle-Vue-Contrôleur
 Modèle :
 Représente le comportement de l’application :

Traitements des données, interactions avec la base de données, etc.
 Il décrit ou contient les données manipulées par l’application.
 Il assure la gestion de ces données et garantit leur intégrité.
 Dans le cas typique d’une base de données, c'est le modèle qui la contient.
Modèle-Vue-Contrôleur
 Vue :
 Correspond à l’interface avec laquelle l’utilisateur interagit.
 Sa première tâche est de présenter les résultats renvoyés par le modèle.
 Sa seconde tâche est de recevoir toutes les actions de l’utilisateur (clic de souris,
sélection d’une entrée, boutons, etc).
 Ces différents événements sont envoyés au contrôleur.
 La vue n’effectue aucun traitement, elle se contente d’afficher les résultats des
traitements effectués par le modèle.
Modèle-Vue-Contrôleur
 Contrôleur :
 Prend en charge la gestion des événements de synchronisation pour mettre à jour
la vue ou le modèle et les synchroniser.
 Il reçoit tous les événements de l’utilisateur et enclenche les actions à effectuer.

Si une action nécessite un changement des données, le contrôleur demande la
modification des données au modèle, ce dernier avertit la vue que les données
ont changé pour qu’elle se mette à jour.
 Certains événements de l’utilisateur ne concernent pas les données mais la vue.

Dans ce cas, le contrôleur demande à la vue de se modifier.
Exemple : gestion des emplois du temps
 Dans le cas d’une base de données des emplois du temps, une action de l’utilisateur
peut être l’entrée (saisie) d’un nouveau cours.
 Le contrôleur ajoute ce cours au modèle et demande sa prise en compte par la vue.
 Une action de l’utilisateur peut aussi être de sélectionner une nouvelle personne pour
visualiser tous ses cours. Ceci ne modifie pas la base des cours mais nécessite
simplement que la vue s’adapte et offre à l’utilisateur une vision des cours de cette
personne.
 Flux de traitement dans le cas général : lorsqu’un client envoie une requête à
l’application :
 La requête envoyée depuis la vue est analysée par le contrôleur,
 Le contrôleur demande au modèle approprié d’effectuer les traitements,
 Le contrôleur renvoie la vue adaptée, si le modèle ne l’a pas déjà fait.
Composants Swing
 Il existe des composants Swing équivalents pour chacun des composants AWT avec
des constructeurs semblables.
 Les principales différences sont :

Utilisation du double buffering qui améliore les rafraichissements.

Utilisation d'un panneau de contenu (contentPane) pour insérer des
composants.
Double-buffering
 L'affichage par défaut d’un composant AWT ou Swing se fait à l'aide d'un simple
buffer (on voit l'image se tracer).
 Si on commence à faire des animations un peu complexes (jeux vidéo en 3D), il
apparait dès lors des problèmes de scintillements de l'image appelés clipping.
 Le double-buffering est le fait d'avoir un buffer où l'on dessine en mémoire et un
buffer qui s'occupe de l'affichage.
 Les problèmes de rafraichissement, saut d'image et autres bugs visuels sont ainsi
éliminés.
 Double-buffering software : c'est une couche de la JVM qui s'en charge.
 Principe : dessiner sur le buffer mémoire (des images, des textes, des dessins, ...),
ensuite, dessiner le buffer mémoire dans le buffer d'affichage (séparation entre le
chargement et l’affichage).

Ne suffisait pas parfois, notamment pour faire des jeux et d'autres
applications graphiques très lourdes.
Double-buffering
 Double-buffering hardware (page-flipping) : c’est le fait d'utiliser un pointeur
vidéo pour décider quel buffer sert de mémoire et quel buffer sert d'affichage.
 Implémenter l'utilisation de la carte graphique VRAM (mémoire vidéo) au lieu de la
RAM afin de diminuer une grande partie des calculs.
 Principe :
 Créer un buffer qui va servir de buffer mémoire (celui où l'on dessine dessus),
puis créé un buffer qui va servir de buffer graphique (celui qui s'occupe d'afficher
ce qu'il contient à l'écran).
 Dessiner sur le buffer mémoire, des images, des textes, des dessins, ... pendant que
le buffer graphique affiche ce qu'il contient. Puis, on swap les buffers (on les
inverse), le buffer mémoire devient le buffer graphique et le buffer graphique
devient le buffer mémoire.
 Habituellement: BackBuffer designe le buffer mémoire et FrontBuffer designe le
buffer graphique.
Composants Swing
 Les composants ne sont plus insérés directement au JFrame mais à l'objet
contentPane qui lui est associé.
 JFrame représente une fenêtre principale qui possède un titre, une taille modifiable et
éventuellement un menu.
 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.
JFrame
javax.swing
Class JFrame
java.lang.Object
java.awt.Component
java.awt.Container
java.awt.Window
java.awt.Frame
javax.swing.JFrame
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.
Constructeur:
JFrame()
JFrame(String): Création d'une instance en précisant le titre
Comportement par défaut à la fermeture
import javax.swing.*;
import java.awt.Toolkit;
public class swing3 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300,100);
f.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
f.setIconImage(Toolkit.getDefaultToolkit().getImage("moi.jpeg"));
f.setVisible(true);
}
}
WindowConstants.DISPOSE_ON_CLOSE : détruit la fenêtre.
WindowConstants.DO_NOTHING_ON_CLOSE : rend le bouton de fermeture inactif.
WindowConstants.HIDE_ON_CLOSE : cache la fenêtre.
Centrer une JFrame à l’écran
 Par défaut, une JFrame est affichée dans le coin supérieur gauche de l'écran. Pour la
centrer dans l'écran, il faut déterminer la position de la JFrame en fonction de sa
dimension et de celle de l'écran et utiliser la méthode setLocation() pour affecter cette
position.
 Exemple:
import javax.swing.*;
import java.awt.*;
public class swing3 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300,100);
f.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
f.setLocation(dim.width/2 - f.getWidth()/2, dim.height/2 - f.getHeight()/2);
f.setVisible(true);
}
}
JLabel
 Le composant JLabel propose les mêmes fonctionnalités que les intitulés AWT mais ils
peuvent en plus contenir des icônes.
 Cette classe possède plusieurs constructeurs :
 JLabel(): Création d'une instance sans texte ni image.
 JLabel(Icon): Création d'une instance en précisant l'image.
 JLabel(Icon, int): Création d'une instance en précisant l'image et l'alignement
horizontal.
 JLabel(String): Création d'une instance en précisant le texte.
 JLabel(String, Icon, int): Création d'une instance en précisant le texte, l'image et
l'alignement horizontal.
 JLabel(String, int): Création d'une instance en précisant le texte et l'alignement
horizontal.
JLabel
import javax.swing.*;
Exécution :
import java.awt.*;
public class swing3 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(600,200);
JPanel pannel = new JPanel();
JLabel jLabel1 =new JLabel("Bonjour");
pannel.add(jLabel1);
ImageIcon icone = new ImageIcon("book.gif");
JLabel jLabel2 =new JLabel(icone);
pannel.add(jLabel2);
JLabel jLabel3 =new JLabel("Tous le monde",icone,SwingConstants.RIGHT);
pannel.add(jLabel3);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
Remarque : L'icône doit être au format GIF et peut être une animation dans ce format.
JLabel
 La classe JLabel définit plusieurs méthodes pour modifier l'apparence du composant :
 setText() : Permet d'initialiser ou de modifier le texte affiché.
 setOpaque() : Indique si le composant est transparent (paramètre false) ou opaque (true).
 setBackground() : Indique la couleur de fond du composant (setOpaque doit être à true).
 setFont() : Permet de préciser la police du texte.
 setForeground() : Permet de préciser la couleur du texte.
 setHorizontalAlignment() : Permet de modifier l'alignement horizontal du texte et de l'icône.
 setVerticalAlignment() : Permet de modifier l'alignement vertical du texte et de l'icône.
 setHorizontalTextAlignment() : Permet de modifier l'alignement horizontal du texte
uniquement.
 setVerticalTextAlignment() : Permet de modifier l'alignement vertical du texte uniquement.
 setIcon() : Permet d'assigner une icône.
 setDisabledIcon() : Permet d'assigner une icône dans un état désactivée.
JLabel
 L'alignement vertical par défaut d'un JLabel est centré.
Exemple: par défaut est soit à droite si il ne contient que du texte, soit
 L'alignement horizontal
import
javax.swing.*;
centré si il contient
une
image avec ou sans texte.
java.awt.*;il suffit d'utiliser les méthodes ci dessus en utilisant des
 Pour modifier import
cet alignement,
class swing3
constantes enpublic
paramètres
: {SwingConstants.LEFT, SwingConstants.CENTER,
public static
void main(String argv[])
{
SwingConstants.RIGHT,
SwingConstants.TOP,
SwingConstants.BOTTOM.
JFrame
= new JFrame("ma
fenetre");
 Par défaut, un JLabel
estf transparent
: son fond
n'est pas dessiné.
 Pour le dessiner, ilf.setSize(200,80);
faut utiliser la méthode setOpaque().
JPanel pannel = new JPanel();
JLabel jLabel1 =new JLabel("Bonjour");
jLabel1.setBackground(Color.red);
pannel.add(jLabel1);
JLabel jLabel2 =new JLabel("Le monde");
jLabel2.setBackground(Color.red);
jLabel2.setOpaque(true);
pannel.add(jLabel2);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
Exécution:
JLabel
 Il est possible d'associer un raccourci clavier au JLabel qui permet de donner le focus à
un autre composant.
 La méthode setDisplayedMnemonic() permet de définir le raccourci clavier.
 Celui ci sera activé en utilisant la touche Alt avec le caractère fourni en paramètre.
 La méthode setLabelFor() permet d'associer le composant fourni en paramètre au
raccourci.
import javax.swing.*;
import java.awt.*;
public class swing3 {
public static void main(String argv[]) {
JFrame f = new JFrame("SAISIE");
f.setSize(600,80);
JPanel pannel = new JPanel();
JButton bouton1 = new JButton("MON ESPACE");
pannel.add(bouton1);
JLabel jLabel1 =new JLabel("Identifiant : ");
Exécution :
jLabel1.setForeground(Color.red);
pannel.add(jLabel1);
JTextField jEdit1 = new JTextField("Saisissez votre identifant");
pannel.add(jEdit1);
jLabel1.setDisplayedMnemonic('d');
jLabel1.setLabelFor(jEdit1);
JLabel jLabel2 =new JLabel("Mot de passe : ");
pannel.add(jLabel2);
JTextField jEdit2 = new JTextField("
");
pannel.add(jEdit2);
JButton bouton2 = new JButton("OK");
pannel.add(bouton2);
f.getContentPane().add(pannel);
f.setVisible(true); }}
JLabel
JButton
import javax.swing.*;
public class swing3 {
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);
}
}
JButton
import javax.swing.*;
import java.awt.event.*;
public class TestJButton3 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(200,100);
JPanel pannel = new JPanel();
JButton bouton1 = new JButton("Quitter");
bouton1.addActionListener( new ActionListener()
{
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
}
);
pannel.add(bouton1);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
JButton
 Dans un conteneur de type JRootPane, il est possible de définir un bouton par défaut
import
javax.swing.*;
grâce
à sa méthode
setDefaultButton().
import java.awt.*;
 Le bouton par défaut est activé par un appui sur la touche Entrée alors que le bouton
class TestJButton2 {
actifpublic
est activé
par un appui sur la barre d'espace.
public static void main(String argv[]) {
 La méthode isDefaultButton() de JButton permet de savoir si le composant est le
JFrame f = new JFrame("ma fenetre");
bouton par défaut.
f.setSize(300,100);
JPanel pannel = new JPanel();
JButton bouton1 = new JButton("Bouton 1");
pannel.add(bouton1);
JButton bouton2 = new JButton("Bouton 2");
pannel.add(bouton2);
JButton bouton3 = new JButton("Bouton 3");
pannel.add(bouton3);
f.getContentPane().add(pannel);
f.getRootPane().setDefaultButton(bouton3);
f.setVisible(true);
}
}
ButtonGroup et RadioButton
import
javax.swing.*;
 La
classe ButtonGroup permet de gérer un ensemble de boutons en garantissant qu'un
public class TestGroupButton1 {
seul bouton du groupe sera sélectionné.
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300,100);
JPanel pannel = new JPanel();
ButtonGroup groupe = new ButtonGroup();
JRadioButton bouton1 = new JRadioButton("Bouton 1");
groupe.add(bouton1);
pannel.add(bouton1);
JRadioButton bouton2 = new JRadioButton("Bouton 2");
groupe.add(bouton2);
pannel.add(bouton2);
JRadioButton bouton3 = new JRadioButton("Bouton 3");
groupe.add(bouton3);
pannel.add(bouton3);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
JCheckBox
import javax.swing.*;
public class swing6 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300,100);
JPanel pannel = new JPanel();
JCheckBox bouton1 = new JCheckBox("Bouton 1");
pannel.add(bouton1);
JCheckBox bouton2 = new JCheckBox("Bouton 2");
pannel.add(bouton2);
JCheckBox bouton3 = new JCheckBox("Bouton 3");
pannel.add(bouton3);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
Un groupe de cases à cocher peut être défini avec la classe ButtonGroup. Dans ce cas,
un seul composant du groupe peut être sélectionné.
JPanel
 La classe JPanel est un conteneur utilisé pour regrouper et organiser des composants
grâce à un gestionnaire de présentation (layout manager).
 Le gestionnaire par défaut d'un JPanel est un objet de la classe FlowLayout.
 AbstractButton est une classe abstraite dont héritent les boutons Swing JButton,
JMenuItem et JToggleButton.
 Cette classe définit de nombreuses méthodes dont les principales sont :
 AddActionListener : Associer un écouteur sur un événement de type ActionEvent.
 getText() : Obtenir le texte affiché par le composant.
 setEnabled() : Activer/désactiver le composant.
 setMnemonic() : Associer un raccourci clavier.
JPanel
 setPressedIcon() : Associer une icône affichée lorsque le composant est cliqué.
 setRolloverIcon() : Associer une icône affichée lors du passage de la souris sur le
composant.
 setRolloverSelectedIcon() : Associer une icône affichée lors du passage de la
souris sur le composant à l'état sélectionné.
 setSelectedIcon() : Associer une icône affichée lorsque le composant à l'état
sélectionné.
 setText() : Mettre à jour le texte du composant.
 isSelected() : Indiquer si le composant est dans l'état sélectionné.
 setSelected() : Mettre à jour l'état sélectionné du composant.
Insertion des images
 Image dans un JButton (ImageIcon)
 Il est possible de préciser une image différente lors du passage de la souris sur le
composant et lors de l'enfoncement du bouton : dans ce cas, il faut créer trois
images pour chacun des états (normal, enfoncé et survolé).
 L'image normale est associée au bouton grâce au constructeur, l'image enfoncée
grâce à la méthode setPressedIcon() et l'image lors d'un survole grâce à la
méthode setRolloverIcon().
 Il suffit enfin d'appeler la méthode setRolloverEnable() avec en paramètre la
valeur true.
Insertion des images
import javax.swing.*;
import java.awt.event.*;
public class swing4 extends JFrame {
public swing4() {
ImageIcon imageNormale = new ImageIcon("cube3.gif");
ImageIcon imagePassage = new ImageIcon("cube2.gif");
ImageIcon imageEnfoncee = new ImageIcon("cube1.gif");
JButton bouton = new JButton("CUBE",imageNormale);
bouton.setPressedIcon(imageEnfoncee);
bouton.setRolloverIcon(imagePassage);
bouton.setRolloverEnabled(true);
getContentPane().add(bouton, "Center");
JPanel panneau = new JPanel();
panneau.add(bouton);
setContentPane(panneau);
setSize(250,250);
setVisible(true);
}
public static void main(String [] args){
JFrame frame = new swing4();
}
}
Insertion des images
Insertion des images
 Image dans un JLabel (ImageIcon)
import java.awt.BorderLayout;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class MonApp extends JFrame {
public MonApp (String texte){
super (texte);
JLabel label = new JLabel(new ImageIcon("livre.gif") );
add(label, BorderLayout.CENTER);
pack();
setVisible(true);
}
public static void main(String[] args) {
new MonApp ("Afficher image");
}
}
Insertion des images
 Image dans un JPanel (paint après ImageIO.read) : à partir de Java 1.4, il est possible
d'utiliser la classe javax.imageio.ImageIO.
import java.awt.*;
import java.awt.image.*;
import java.io.*;
import javax.imageio.*;
import javax.swing.*;
class AfficheImage1 extends JPanel {
private BufferedImage image;
public AfficheImage1(String nomFichier) {
try { image = ImageIO.read (
new File(nomFichier));
this.setPreferredSize(new
Dimension(image.getWidth(),
image.getHeight()));
} catch (IOException ie) {
ie.printStackTrace(); } }
public void paint(Graphics g) {
g.drawImage(image, 0, 0, this);
}}
public class MonApp1 extends JFrame {
public MonApp1(String titre) {
super(titre);
init();
}
private void init()
{
AfficheImage1 afficheImage =
new AfficheImage1("Livre.gif");
this.setLayout(new BorderLayout());
this.add(afficheImage, BorderLayout.CENTER);
this.pack();
}
public static void main(String[] args) {
MonApp1 app = new MonApp1("Afficher image");
app.setVisible(true);
}}
Insertion des images
Insertion des images
 Image dans un JPanel (paint après getImage)
import java.awt.*;
import javax.swing.*;
class AfficheImage2 extends JPanel {
private Image image;
public AfficheImage2 (String filename) {
java.net.URL url = this.getClass().getResource("livre.gif");
image = Toolkit.getDefaultToolkit().getImage(url);
try {
MediaTracker mt = new MediaTracker(this);
mt.addImage(image, 0);
mt.waitForAll();
} catch (Exception e) { e.printStackTrace(); }
this.setPreferredSize(new Dimension(image.getWidth(this),
image.getHeight(this)));
}
public void paint(Graphics g) {
g.drawImage(image, 0, 0, this);
}}
public class MonApp3 extends JApplet {
public void init() {
add (new AfficheImage2 ("LIVRE"));
}}
Composants de saisie de texte
 JTextComponent : La classe abstraite JTextComponent est la classe mère de tout les
composants permettant la saisie de texte.
JTextComponent
JEditorPane
JTextArea
JTextField
JPasswordField
Composants de saisie de texte
 JTextComponent possède de nombreuses méthodes dont les principales sont :
 String getText(int, int) : Renvoyer une portion du texte incluse à partir de la
position donnée par le premier paramètre et la longueur donnée dans le second
paramètre.
 bool isEditable() : Renvoyer un booléen qui précise si le texte est éditable ou
non.
 void select(int,int) : Sélectionner une portion du texte dont les positions de
début et de fin sont fournies en paramètres.
 int getSelectionEnd() : Renvoyer la position de la fin de la sélection.
 int getSelectionStart() : Renvoyer la position du début de la sélection.
 void copy() : Copier le contenu du texte et le mettre dans le presse papier
système.
 void cut() : Couper le contenu du texte et le mettre dans le presse papier système.
 void paste() : Coller le contenu du presse papier système dans le composant.
Composants de saisie de texte
 String getText() : Renvoyer le texte saisie.
 Document getDocument() : Renvoyer l'objet de type Document qui encapsule
le texte saisi.
 String getSelectectedText() : Renvoyer le texte sélectionné dans le composant.
 void setCaretPosition(int) : Déplacer le curseur à la position dans le texte
précisé en paramètre.
 void setEditable(boolean) : Permet de préciser si les données du composant
sont éditables ou non.
 void setSelectionEnd(int) : Modifier la position de la fin de la sélection.
 void setSelectionStart(int) : Modifier la position du début de la sélection.
 void setText(String) : Modifier le contenu du texte.
JTextField
 JTextField est un composant qui permet la saisie d'une seule ligne de texte simple.
import javax.swing.*;
public class swing7 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300, 100);
JPanel pannel = new JPanel();
JTextField testField1 = new JTextField ("mon texte");
pannel.add(testField1);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
JPasswordField
import java.awt.Dimension;
import javax.swing.*;
public class swing8 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300, 100);
JPanel pannel = new JPanel();
JPasswordField passwordField1 = new JPasswordField ("");
passwordField1.setPreferredSize(new Dimension(100,20 ));
pannel.add(passwordField1);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
La méthode setEchoChar(char) permet de préciser le caractère qui sera utilisé pour afficher la
saisie d'un caractère. Il ne faut pas utiliser la méthode getText() qui est déclarée deprecated mais la
méthode getPassword() pour obtenir la valeur du texte saisi.
JPasswordField
import java.awt.Dimension;
import java.awt.event.*;
import javax.swing.*;
public class swing9 implements ActionListener {
JPasswordField passwordField1 = null;
public static void main(String argv[]) {
swing9 jpf = new swing9();
jpf.init(); }
public void init() {
JFrame f = new JFrame("ma fenetre");
f.setSize(300, 100);
JPanel pannel = new JPanel();
passwordField1 = new JPasswordField("");
passwordField1.setPreferredSize(new Dimension(100, 20));
pannel.add(passwordField1);
JButton bouton1 = new JButton("Afficher");
bouton1.addActionListener(this);
pannel.add(bouton1);
f.getContentPane().add(pannel);
f.setVisible(true); }
public void actionPerformed(ActionEvent e) {
System.out.println("texte saisie = " +
String.copyValueOf(passwordField1.getPassword()));
}
}
import java.net.URL;
import javax.swing.*;
import javax.swing.event.*;
public class swing10 {
static
Ce void
composant
permet
de texte riche multi-lignes.
public
main(String[]
args)de
{ saisiepublic
interface HyperlinkListener extends EventListener
finalJEditorPane
Ce type editeur;
de texte peut contenir Possède
des informations
de mise
en pages et de formatage.
une seule méthode
hyperlinkUpdate
JPanel pannel
= new Swing
JPanel(); propose le support des formats RTF et HTML.
standard,
try { editeur = new JEditorPane(new URL("http://www.google.com"));
editeur.setEditable(false);
JEditorPane
editeur.addHyperlinkListener(new HyperlinkListener() {
public void hyperlinkUpdate(HyperlinkEvent e) {
if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
URL url = e.getURL();
if (url == null)
return;
try { editeur.setPage(e.getURL());
} catch (Exception ex) {
ex.printStackTrace();
}}
}
});
pannel.add(editeur);
} catch (Exception e1) {
e1.printStackTrace(); }
JFrame f = new JFrame("ma fenetre");
f.setSize(750, 500);
f.getContentPane().add(pannel);
f.setVisible(true);
}}
En
JEditorPane
JTextArea
 JTextArea est un composant qui permet la saisie de texte simple en mode multi-lignes.
Le modèle utilisé par ce composant est le PlainDocument : il ne peut donc contenir
que du texte brut sans éléments multiples de formatage.
 JTexteArea propose plusieurs méthodes pour ajouter du texte dans son modèle :
 Fournir le texte en paramètre du constructeur utilisé.
 Utiliser la méthode setText() qui permet d'initialiser le texte du composant.
 Utiliser la méthode append() qui permet d'ajouter du texte à la fin de celui
contenu dans le texte du composant.
 Utiliser la méthode insert() permet d'insérer un texte à une position données en
caractères dans le texte du composant.
JTextArea
 La méthode replaceRange() permet de remplacer une partie du texte désignée par la
position du caractère de début et la position de son caractère de fin par le texte fourni
en paramètre.
 La propriété rows permet de définir le nombre de ligne affichée par le composant :
 Cette propriété peut donc être modifiée lors d'un redimensionnement du
composant.
 La propriété lineCount en lecture seule permet de savoir le nombre de lignes dont le
texte est composé. Il ne faut pas confondre ces deux propriétés.
JTextArea
import javax.swing.*;
public class JTextArea1 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300, 100);
JPanel pannel = new JPanel();
JTextArea textArea1 = new JTextArea ("mon texte");
pannel.add(textArea1);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
JScrollPane
 Par défaut, la taille du composant augmente au fur et à mesure de l'augmentation de la
taille du texte qu'il contient. Pour éviter cet effet, il faut encapsuler le JTextArea dans
un JScrollPane.
import java.awt.Dimension;
import javax.swing.*;
public class JTextArea1 {
public static void main(String argv[]) {
JFrame f = new JFrame("ma fenetre");
f.setSize(300, 100);
JPanel pannel = new JPanel();
JTextArea textArea1 = new JTextArea ("mon texte");
JScrollPane scrollPane = new JScrollPane(textArea1);
scrollPane.setPreferredSize(new Dimension(200,70));
pannel.add(scrollPane);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
JTabbedPane : les onglets
import java.awt.Dimension;
import
 java.awt.event.KeyEvent;
La classe javax.swing.JTabbedPane encapsule un ensemble d'onglets.
import javax.swing.*;
 Chaque onglet est constitué d’un titre, d'un composant et éventuellement
public class TestJTabbedPane1
{
image.
public static void main(String[] args) {
JFrame f = new JFrame("Test JTabbedPane");
f.setSize(320, 150);
JPanel pannel = new JPanel();
JTabbedPane onglets = new JTabbedPane(SwingConstants.TOP);
JPanel onglet1 = new JPanel();
JLabel titreOnglet1 = new JLabel("Onglet 1");
onglet1.add(titreOnglet1);
onglet1.setPreferredSize(new Dimension(300, 80));
onglets.addTab("onglet1", onglet1);
JPanel onglet2 = new JPanel();
JLabel titreOnglet2 = new JLabel("Onglet 2");
onglet2.add(titreOnglet2);
onglets.addTab("onglet2", onglet2);
onglets.setOpaque(true);
pannel.add(onglets);
f.getContentPane().add(pannel);
f.setVisible(true);
}
}
d'une
JTabbedPane : les onglets
 A partir du JDK 1.4, il est possible d’ajouter un raccourci clavier sur chacun des onglets en
utilisant la méthode setMnemonicAt().
 Cette méthode attend deux paramètres : l’index de l’onglet concerné (le premier
commence à 0) et la touche du clavier associée sous la forme d’une constance
KeyEvent.VK_xxx.
 Pour utiliser ce raccourci, il suffit d'utiliser la touche désignée en paramètre de la
méthode avec la touche Alt.
JTabbedPane : les onglets
 La classe JTabbedPane possède plusieurs méthodes qui permettent de définir le contenu de
l’onglet :
 addTab(String, Component) : Permet d'ajouter un nouvel onglet dont le titre et le
composant sont fournis en paramètres. Cette méthode possède plusieurs surcharges qui
permettent de préciser une icône et une bulle d'aide.
 insertTab(String, Icon, Component, String, index) : Permet d'insérer un onglet dont
la position est précisée dans le dernier paramètre.
 remove(int) : Permet de supprimer l'onglet dont l'index est fourni en paramètre.
 setTabPlacement : Permet de préciser le positionnement des onglets dans le
composant JTabbedPane, les valeurs possibles sont les constantes TOP, BOTTOM,
LEFT et RIGHT définies dans la classe JTabbedPane.
 getSelectedIndex() permet d'obtenir l'index de l'onglet courant.
 setSelectedIndex() permet de définir l'onglet courant.
Menus
 Les menus de Swing proposent certaines caractéristiques intéressantes en plus de celle
proposées par un menu standard :
 Les éléments de menu peuvent contenir une icône.
 Les éléments de menu peuvent être de type bouton radio ou case à cocher.
 Les éléments de menu peuvent avoir des raccourcis clavier.
 Les menus sont mis en œuvre dans Swing avec un ensemble de classe :
 JMenuBar : encapsule une barre de menu.
 JMenu : encapsule un menu.
 JMenuItem : encapsule un élément d'un menu.
 JCheckBoxMenuItem : encapsule un élément d'un menu sous la forme d'une
case à cocher.
 JRadioButtonMenuItem : encapsule un élément d'un menu sous la forme d'un
bouton radio.
 JSeparator : encapsule un élément d'un menu sous la forme d'un séparateur.
 JPopupMenu : encapsule un menu contextuel.
Menus
 Toutes ces classes héritent de façon directe ou indirecte de la classe JComponent.
Les éléments de menus cliquables héritent de la classe JAbstractButton. JMenu hérite de la classe JMenuItem
et non pas l'inverse car chaque JMenu contient un JMenuItem implicite qui encapsule le titre du menu. La
plupart des classes utilisées pour les menus implémentent l'interface MenuElement. Cette interface définit des
méthodes pour la gestion des actions standards de l'utilisateur. Ces actions sont gérées par la classe
MenuSelectionManager.
Menus
Menus
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Menu1 extends JMenuBar {
public Menu1() {
// Listener générique qui affiche l'action du menu utilisé
ActionListener afficherMenuListener = new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.out.println("Elément de menu [" + event.getActionCommand()
+ "] utilisé.");
}
};
// Création du menu Fichier
JMenu fichierMenu = new JMenu ("Fichier");
JMenuItem item = new JMenuItem ("Nouveau", 'N');
item.addActionListener (afficherMenuListener);
fichierMenu.add(item);
item = new JMenuItem ("Ouvrir", 'O');
item.addActionListener (afficherMenuListener);
fichierMenu.add(item);
item = new JMenuItem ("Sauver", 'S');
item.addActionListener (afficherMenuListener);
fichierMenu.insertSeparator(1);
fichierMenu.add (item);
item = new JMenuItem ("Quitter");
item.addActionListener (afficherMenuListener);
fichierMenu.add (item);
Menus
// Création du menu Editer
JMenu editerMenu = new JMenu("Editer");
item = new JMenuItem("Copier");
item.addActionListener(afficherMenuListener);
item.setAccelerator(KeyStroke.getKeyStroke('C', Toolkit.
getDefaultToolkit().getMenuShortcutKeyMask(), false));
editerMenu.add(item);
item = new JMenuItem("Couper");
item.addActionListener(afficherMenuListener);
item.setAccelerator(KeyStroke.getKeyStroke('X', Toolkit.
getDefaultToolkit().getMenuShortcutKeyMask(), false));
editerMenu.add(item);
item = new JMenuItem("Coller");
item.addActionListener(afficherMenuListener);
item.setAccelerator(KeyStroke.getKeyStroke('V', Toolkit.
getDefaultToolkit().getMenuShortcutKeyMask(), false));
editerMenu.add(item);
Menus
// Création du menu Divers
JMenu diversMenu = new JMenu("Divers");
JMenu sousMenuDiver1 = new JMenu("Sous menu 1");
item = new JMenuItem("Sous menu 1 1");
sousMenuDiver1.add(item);
item.addActionListener(afficherMenuListener);
JMenu sousMenuDivers2 = new JMenu("Sous menu 1 2");
item = new JMenuItem("Sous menu 1 2 1");
sousMenuDivers2.add(item);
item.addActionListener(afficherMenuListener);
sousMenuDiver1.add(sousMenuDivers2);
diversMenu.add(sousMenuDiver1);
item = new JCheckBoxMenuItem("Validé");
diversMenu.add(item);
item.addActionListener(afficherMenuListener);
diversMenu.addSeparator();
ButtonGroup buttonGroup = new ButtonGroup();
item = new JRadioButtonMenuItem("Cas 1");
diversMenu.add(item);
item.addActionListener(afficherMenuListener);
buttonGroup.add(item);
item = new JRadioButtonMenuItem("Cas 2");
diversMenu.add(item);
item.addActionListener(afficherMenuListener);
buttonGroup.add(item);
diversMenu.addSeparator();
diversMenu.add(item = new JMenuItem ("Autre",
new ImageIcon ("info.png")));
item.addActionListener(afficherMenuListener);
Menus
// ajout des menus à la barre de menu
add (fichierMenu);
add (editerMenu);
add (diversMenu);
}
public static void main(String s[]) {
JFrame frame = new JFrame ("Test de menu");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setJMenuBar (new Menu1());
frame.setMinimumSize (new Dimension(250, 200));
frame.pack();
frame.setVisible(true);
}
}
Menus
Classe JMenuBar
 La classe JMenuBar encapsule une barre de menu qui contient zéro ou plusieurs
menus.
 La classe JMenuBar utilise la classe DefaultSingleSelectionModel comme modèle de
données : un seul de ces menus peut être activé à un instant t.
 Pour ajouter des menus à la barre de menu, il faut utiliser la méthode add() de la classe
JMenuBar qui attend en paramètre l'instance du menu.
 Pour ajouter la barre de menu à une fenêtre, il faut utiliser la méthode setJMenuBar()
d'une instance des classes JFrame, JInternalFrame, JDialog ou JApplet.
 Comme la classe JMenuBar hérite de la classe JComponent, il est aussi possible
d'instancier plusieurs JMenuBar et de les insérer dans un gestionnaire de
positionnement comme n'importe quel composant.
 Ceci permet aussi de placer le menu à sa guise.
 Swing n'impose pas d'avoir un unique menu par fenêtre : il est possible d'avoir
plusieurs menus dans une même fenêtre.
Classe JMenuBar
 La classe JMenuBar ne possède qu'un seul constructeur sans paramètre.
 Les principales méthodes de la classe JMenuBar sont :
 JMenu add(JMenu) : ajouter un menu à la barre de menu.
 JMenu getMenu(int) : obtenir le menu dont l'index est fourni en paramètre.
 int getMenuCount() : obtenir le nombre de menu de la barre de menu.
 MenuElement[] getSubElements() : obtenir un tableau de tous les menus.
 boolean isSelected() : précise si un menu est affiché.
Classe JMenuBar
...
public static void main(String s[]) {
JFrame frame = new JFrame ("Test de menu");
frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
Menu1 menu = new Menu1();
frame.getContentPane().add (menu, BorderLayout.SOUTH);
frame.setMinimumSize (new Dimension(250, 200));
frame.pack();
frame.setVisible(true);
}
...
Classe JMenuBar
...
public static void main(String s[]) {
…
frame.setJMenuBar (new Menu1());
frame.getContentPane().add (new Menu1(), BorderLayout.SOUTH);
…
}
...
Classe JMenuItem
 La classe JMenuItem encapsule les données d'un élément de menu (libellé et/ou
image). Elle hérite de la classe AbstractButton.
 Les éléments de menu peuvent être associés à deux types de raccourcis clavier :
 Accelerators : ils sont hérités de JComponent : ce sont des touches (par exemple
les touches de fonctions) ou des combinaisons de touches avec les touches shift,
Ctrl ou Alt qui sont affichées à la droite du libellé de l'élément du menu.
 Mnemonics : ils apparaissent sous la forme d'une lettre soulignée. Ils sont
utilisables seulement sur certaines plate-formes (par exemple en combinaison avec
la touche Alt sous Windows).
 La méthode setAccelerator() permet d'associer un accelerator à un élément de type
JMenuItem.
Classe JMenuItem
 Un mnemonic peut être associé à JMenuItm de deux façons :
 Soit dans la surcharge du constructeur prévu à cet effet.
 Soit en utilisant la méthode setMnemonic().
 Le mnemonic correspond à un caractère qui doit obligatoirement être contenu dans le
libellé.
 Un élément de menu peut contenir uniquement une image ou être composé d'un
libellé et d'une image.
 Une image peut être associée à un JMenuItem de deux façons :
 Soit dans une des surcharges du constructeur prévu à cet effet

item = new JMenuItem ("Autre", new ImageIcon("info.png"));

item = new JMenuItem (new ImageIcon("info.png"));
 Soit en utilisant la méthode setIcon

item.setIcon (new ImageIcon("info.png"));
Classe JPopupMenu
 La classe JPopupMenu encapsule un menu flottant qui n'est pas rattaché à une barre
de menu mais à un composant.
 La création d'un JPopMenu est similaire à la création d'un JMenu.
 Il est préférable d'ajouter un élément de type JMenuItem grâce à la méthode add() de
la classe JPopupMenu mais il est aussi d'ajouter n'importe quel élément qui hérite de la
classe Component en utilisant une surcharge de la méthode add().
 Il est possible d'ajouter un élément à un index précis en utilisant la méthode insert().
 La méthode addSeparator() permet d'ajouter un élément séparateur.
 Pour afficher un menu flottant, il faut ajouter un listener sur l'événement déclenchant
et utiliser la méthode show() de la classe JPopupMenu.
Classe JPopupMenu
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Menu2 extends JMenuBar {
public static void main(String s[]) {
JFrame frame = new JFrame("Test de menu divers");
final JPopupMenu popup = new JPopupMenu();
final JTextField texte = new JTextField();
frame.add(texte);
JMenuItem item = new JMenuItem("Copier");
popup.add(item);
item.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
texte.copy();
}
});
item = new JMenuItem("Coller");
popup.add(item);
item.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
texte.paste();
}
});
texte.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
afficherPopup(e); }
public void mousePressed(MouseEvent e) {
afficherPopup(e); }
public void mouseReleased(MouseEvent e) {
afficherPopup(e); }
private void afficherPopup(MouseEvent e) {
if (e.isPopupTrigger()) {
popup.show(texte, e.getX(), e.getY());
}}
});
frame.setMinimumSize (new Dimension(250, 200));
frame.pack();
frame.setVisible(true);
}}
isPopupTrigger() : indique l’événement de la souris
qui déclenche le menu flottant. Cet événement est
différent d’une plate-forme à une autre, c’est pour cette
raison qu’il est présent dans les différentes méthodes
(mouseReleased, mousePressed, mouseClicked).
Classe JMenu
 La classe JMenu encapsule un menu qui est attaché à un objet de type JMenuBar ou à
un autre objet de type JMenu. Dans ce second cas, l'objet est un sous menu.
 Il est possible d'ajouter un élément sous la forme d'un objet de type JMenuItem,
Component ou Action en utilisant la méthode add().
 Chaque élément du menu possède un index.
 La méthode remove() permet de supprimer un élément du menu en fournissant en
paramètre l'instance de l'élément ou son index. Si la suppression réussie, les index des
éléments suivants sont décrémentés d'une unité.
Classe JMenu
 La classe JMenu possède plusieurs propriétés :
 popupMenu : JPopupMenu qui encapsule les éléments du menu.
 topLevelMenu : propriété en lecture seule qui précise si le menu est attaché à un
JMenuBar.

La valeur false indique que le menu est un sous menu attaché à un autre
menu.
 itemCount : indique le nombre d'éléments du menu (incluant les séparateurs).
 delay : précise le temps en milliseconde avant l'affichage du menu.
 menuComponentCount : indique le nombre de composants du menu.
Classe JMenu
 Quelques méthodes :
 getMenuComponent() : permet d'obtenir le composant du menu dont l'index est
fourni en paramètre.
 getItem() : permet d'obtenir le JMenuItem dont l'index est fourni en paramètre.
 menuComponents() : renvoie un tableau des composants du menu.
 isMenuComponent() : renvoie un booléen qui précise si le composant fourni en
paramètre est inclus dans les éléments du menu.
Classe JMenu
 Un événement de type MenuEvent est émis lorsque le titre du menu est cliqué.
 Un listener de type MenuListener permet de s'abonner à ces événements.
 MenuListener définie trois méthodes qui possède un paramètre de type MenuEvent :
 menuCanceled() : invoquée lorsque le menu est effacé.
 menuDeselected() : invoquée lorsque le titre du menu est désélectionné.
 menuSelected() : invoquée lorsque le titre du menu est sélectionné.
JCheckBoxMenuItem
 Cette classe encapsule un élément du menu qui contient une case à cocher.
 Elle possède de nombreux constructeurs qui permettent de préciser le texte, une icône
et l'état de la case à cocher.
 La propriété state() permet de connaître ou de positionner l'état de la case à cocher.
JRadioButtonMenuItem
 Cette classe encapsule un élément de menu qui contient un bouton radio.
 Les boutons radio associés à un même groupe sont mutuellement non sélectionnable
(un seul bouton radio du groupe peut être sélectionné à la fois).
 La définition de ce groupe ce fait en utilisant la classe ButtonGroup.
 C'est d'ailleurs cette classe qui propose la méthode getSelected() pour connaître le
bouton radio sélectionné dans le groupe.
JSeparator
 La méthode addSeparator() des classe JMenu et JPopupMenu instancie un objet de
type JSeparator et l'ajoute à la liste des éléments du menu.
 La classe JSeparator encapsule un séparateur dans un menu.
 Remarque : cette classe n'est pas utilisable que dans un menu mais peut aussi être
utilisée comme un composant dans l'interface.
Exercice : interface graphique avec Swing et HTML
 Le but de cette exercice est de réaliser l’interface ci-dessus qui permet de saisir du texte
dans un JTextField (en haut), éventuellement au format HTML, qui montre
l'apparence dans le JLabel en dessous, et qui permet de sauver le texte tapé dans un
fichier.
Exercice : interface graphique avec Swing et HTML
 Dans cette exercice, on s'intéresse uniquement à l'interface et aux écouteurs. Lorsqu'on
cliquera sur l'un des boutons, on affichera juste un message dans la console.
 Pour les plus rapides, lorsqu'on clique sur un bouton, on ouvrira un JFileChooser qui
permettra de sélectionner le fichier à charger ou à sauver ; dans ce cas, le message dans
la console reprendra le nom du fichier sélectionné par l'utilisateur
 (par exemple : "on charge le fichier test.html").
Exercice : Box
 Réaliser l’interface suivante à l’aide des classes:
 JFrame
 JPanel
 JButton
 Box
 BoxLayout
 JSeparator
 JTextField
 Dimension

BoxLayout est le gestionnaire de répartition qui permet de mettre des
composants en ligne ou en colonne.

Box est un conteneur dont le gestionnaire est BoxLayout.