cours java

1. Langage JAVA
Pof: R. EL AYACHI
Département d’informatique
Faculté des Sciences et Techniques
Béni Mellal
1

2. Chapitre 4: Interfaces graphiques
A. Package java.awt
1. Possibilités de java.awt
2. Principales classes de java.awt
3. Composants de l’interface graphiques
4. Gestionnaires de mise en page
5. Conteneurs
6. Evénements et actions
A. Package javax.swing
1. Possibilités de javax.swing
2. Paquetages de javax.swing
3. Principaux composants de javax.swing
4. Principaux conteneurs de javax.swing
5. Eléments décoratifs
Prof: R. EL AYACHI
2

3. * En java, il existe plusieurs paquetages dédiés au graphisme, les
plus utilisés sont:
 java.awt (Abstract Windowing Toolkit) fournit au programmeur
toutes les classes nécessaires à la gestion du graphisme.
 javax.swing offre beaucoup plus de composants que le
paquetage java.awt . Il permet de réaliser de véritables interfaces
homme-machine.
* Principes de base de awt et swing:
 Créer un cadre
 Créer des composants
 Utiliser une mise en page pour ces composants
 Insérer les composants dans un cadre
 Utiliser des méthodes en réponse aux actions de l’utilisateurs
Introduction
Prof: R. EL AYACHI
3

4. Chapitre 4
Prof: R. EL AYACHI
4
Package java.awt

5. Avec java.awt, on peut par exemple:
 Tracer différentes formes (rectangles, ovales,…)
 Définir des polices des caractères, des couleurs…
 Créer des composants simples tels que boutons,
cases à cocher, libellés, …
 Créer des composants plus complexes tels que
boites de dialogue, menu déroulants, …
Gérer des événements des utilisateurs (clique sur
un bouton, …)
1. Possibilités de java.awt
Prof: R. EL AYACHI
5

6. 1. Classe Graphics
La classe java.awt.Graphics comporte un nombre important de
méthodes permettant de tracer des formes géométriques vides
ou pleines.
Parmi les méthodes, on trouve:
- drawLine(int x1,int y1,int x2,int y2)
- drawString(String texte,int x,int y)
- drawRectangle(int x,int y,int larg,int haut)
- fillRectangle(int x,int y,int larg,int haut)
- drawOval(int x,int y, int larg,int haut)
- fillOval(int x,int y, int larg,int haut)
- drawPolygon(xpoints,ypoints,points)
- fillPolygon(xpoints,ypoints,points)
2. Principales classes de java.awt
Prof: R. EL AYACHI
6

7. 2. Classe Color
La classe java.awt.Color permet la gestion de couleurs en java. Les
couleurs peuvent être spécifiées de plusieurs manières:
- Noms standards prédéfinis (black, blue, red, orange, green, …):
Color.nom_couleur
- Trois nombres entre 0 et 255 (trois couleurs RGB):
Color macouleur=new Color(150,200,250)
- Trois nombres floats entre 0.0 et 1.0:
Color macouleur=new Color(1.0f,0.5f,0.7f)
Remarques:
- La méthode setColor() de java.awt.Graphics : Afficher un texte
ou un graphique dans une couleur spécifique.
- La méthode setBackground(): Définir la couleur de l’arrière plan
2. Principales classes de java.awt
Prof: R. EL AYACHI
7

8. 3. Classe Font
L’affichage d’un caractère est définit par trois éléments:
- Nom de la police: Times Roman, Courier, Helvetica, …
- Style de la police: gras, italique ou normal
- Taille de la police en points
Pour afficher un texte dans une police définie, avec un style défini
et une taille précise, on doit déclarer un objet Font contenant ces
informations. Le constructeur de la classe Font est:
Font(String nom,int style,int taille)
Le style peut être l’une des constantes: Font.PLAIN, Font.BOLD,
Font.ITALIC
Remarque: La méthode getFontList() de java.awt.Toolkit affiche la
liste des polices
2. Principales classes de java.awt
Prof: R. EL AYACHI
8

9. Tracer les formes géométriques suivantes:
Exercice1
Prof: R. EL AYACHI
9

10. En java, les éléments de l’interface utilisateur sont des
composants. C’est-à-dire des objets dérivant de la classe
java.awt.Component. Chaque type d’objet de l’interface
graphique (bouton, texte, case à cocher, …) est une classe
dérivée de Component.
La classe java.awt.Container, qui hérite de Component est capable
de contenir plusieurs objets de la classe Component. Par
exemple un objet de la classe Container peut contenir 2 boutons,
2 cases à cocher, …
Pour utiliser des composants tels que des zones de saisie et des
boutons dans un programme java, il faut créer un objet
composant et l’ajouter à l’aide de la méthode add() de la classe
java.awt.Component.
3. Composants de l’interface graphique
Prof: R. EL AYACHI
10

11. 1. Boutons
Les boutons sont les contrôleurs de tout écran d’interface, ils
permettent de déclencher des événements que l’on peut détecter
et traiter.
Java permet d’utiliser les boutons d’une manière simple et
efficace. La classe java.awt.Button déclare des constructeurs et
des méthodes appropriées.
Pour utiliser un bouton, il faut d’abord le créer en instanciant la
classe Button puis l’ajouter à l’interface à l’aide de la méthode
add().
Prof: R. EL AYACHI
11
3. Composants de l’interface graphique

12. Prof: R. EL AYACHI
12
Code source de l’applet:
//Fichier: DemoBouton.java
import java.applet.*;
import java.awt.*;
public class DemoBouton extends Applet
{
Button monBouton1;
Button monBouton2;
public void int()
{
monBouton1=new Button();
monBouton2=new Button();
monBouton1.setLabel(‘’bouton 1’’);
monBouton2.setLabel(‘’bouton 2’’);
add(monBouton1);
add(monBouton2);
}
}
Code source du fichier HTML:
<HTML>
<HEAD>
<TITLE> Exemple de bouton</TITLE>
</HEAD>
<BODY>
<APPLET CODE= DemoBouton.class″ ″
width=400 height=200>
</APPLET>
</BODY>
</HTML>
3. Composants de l’interface graphique

13. 2. Etiquettes
Une étiquette (label) est une chaine de caractères qui ne dépasse
pas une ligne et qui permet d’afficher un texte qui n’est pas
interactif.
Une étiquette peut être positionnée avec les fonctions de mise en
page. Son rôle consiste à donner des informations sur les autres
contrôles, notamment les zones de saisie.
Pour accéder à une étiquette, il faut d’abord déclarer un objet de
la classe java.awt.Label.
Label etq=new Labet( Je suis une étiquette );″ ″
add(etq);
On peut modifier le texte d’un label en appelant la méthode
setText(): etq.setText( Le nouveau texte );″ ″
Prof: R. EL AYACHI
13
3. Composants de l’interface graphique

14. Prof: R. EL AYACHI
14
import java.awt.*;
class DemoLabel extends Frame
{
Label monEtiquette;
DemoLabel(String titre)
{
super(titre);
monEtiquette = new Label( Une étiquette );″ ″
add(monEtiquette);
}
public static void main(String[] argv)
{
DemoLabel monLabel = new
DemoLabel( Affichage Etiquette );″ ″
monLabel.setSize(400,400);
monLabet.setVisible(true);
}
}
3. Composants de l’interface graphique

15. 3. Boîtes de dialogues
a. Cases à cocher
Un composant Checkbox est une case placée à côté d’une ligne de texte et qui
peut être cochée par l’utilisateur.
Chaque case à cocher (Checkbox) représente un état booléen, vrai ou faux
selon qu’elle est cochée ou non.
Pour gérer les cases à cocher, on utilise la classe java.awt.Checkbox
Checkbox cb = new Checkbox(); // créer une case à cocher
Checkbox cb = new Checkbox(String); // créer une case à cocher et afficher le
texte en argument à côté de la case
Etat d’une case à cocher:
cb.setState(booleen); //true si activée, false sinon
booleen etat=cb.getState(); //true si activée, false sinon
cb.getState(); //retourne la chaîne de caractères correspondant à
l’étiquette de la case à cocher
Prof: R. EL AYACHI
15
3. Composants de l’interface graphique

16. Pour savoir si une action a été déclenchée par l’utilisateur
(pression d’un bouton, coche d’une case,…), il faut redéfinir la
méthode: public booleen action(Event e,Object arg).
La méthode action est appelée automatiquement traite les
événements survenus pendant l’exécution de l’application ou
l’applet. L’objet arg retourne le nom du bouton actionné, ou de la
case cochée,…
Prof: R. EL AYACHI
16
3. Composants de l’interface graphique

17. Prof: R. EL AYACHI
17
import java.awt.*;
public class DemoCheckbox extends Frame
{
static booleen etat=true;
Checkbox test;
DemoCheckbox(String titre)
{
super(titre);
FlowLayout fl=new FlowLayout();
//gestionnaire de la mise en page
setLayout(fl);
test=new Checkbox( TEST );″ ″
add(test);
}
public booleen action(Event e,Object arg)
{
if(test.getState()) {etat=true; repaint();}
else {etat=false; repaint();}
retunr (true);
}
Public void paint()
{
g.setColor(Color.red);
g.setFont( Helevetica ,Font.BOLD,20);″ ″
if(etat==true)
g.drawString( Case activée ,50,300);″ ″
else
g.drawString( Case désactivée ,50,300);″ ″
}
public static void main(String[] arg)
{
DemoCheckbox maCase=new Checkbox( Case″
à cocher );″
maCase.setSize(400,400);
macase.setVisible(true);
}
}
3. Composants de l’interface graphique

18. b. Boutons radio
Une case à cocher peut être affichée individuellement ou dans un
groupe. Les boutons radio sont des cases à cocher rassemblées
dans un groupe. A l’intérieur du groupe, on ne peut activer qu’une
seule case à la fois. La classe java.awt.CheckboxGroup permet de
créer des groupes de boutons radio.
CheckboxGroup br;
Checkbox b1=new Checkbox( Etiquette1 ,etat1,br);″ ″
…
Checkbox bn=new Checkbox( Etiquetten ,etatn,br);″ ″
Prof: R. EL AYACHI
18
3. Composants de l’interface graphique
Etiquetten est
l’étiquette du
bouton radio
etatn est l’état
du bouton:
true ou false
br est le nom du
groupe des
boutons radio

19. 4. Listes déroulantes
Les listes déroulantes sont des composants très appréciés dans les
interfaces utilisateurs. Ils permettent de sélectionner des
éléments dans une liste.
a. Listes à choix unique
Java permet de créer une liste déroulante à choix unique par
l’intermédiaire de la classe java.awt.Choice.
l’objet Choice permet à l’utilisateur de choisir une valeur unique
parmi une liste. La syntaxe est la suivante:
Choice maListe=new Choice();
maListe.addItem( choix 1 );″ ″
…
maListe.addItem( choix n );″ ″
Prof: R. EL AYACHI
19
3. Composants de l’interface graphique

20. Gestion des sélections:
maListe.select(indice); //sélectionne un élément par son indice
maListe.select(élément); //sélectionne un élément par son contenu
maListe.countItems(); //retourne le nombre d’éléments de la liste
maListe.getItem(n); //retourne le contenu de l’élément n
maListe.getSelectedItem(); //retourne le contenu de l’élément sélectionné
maListe.getSelectedIndex(); // retourne l’indice de l’élément sélectionné
Prof: R. EL AYACHI
20
3. Composants de l’interface graphique

21. b. Listes à choix multiple
Une liste à choix multiple permet d’afficher une liste de choix dans
un cadre. Elle permet d’afficher plusieurs lignes et la sélection de
plusieurs lignes.
Pour gérer une liste à choix multiple, on doit faire appel à la classe
java.awt.List.
La classe List contient plusieurs constructeurs, le plus intéressant
est List(int i,booleen valeur). Le premier paramétre i définit le
nombre de lignes qui seront affichées, et la valeur indique si l’on
autorise la sélection multiple (true) ou non.
Une fois l’instance crée, on ajoute des propositions avec
addItem(String).
Prof: R. EL AYACHI
21
3. Composants de l’interface graphique

22. La classe List dispose d’un grand nombre de fonctions pour gérer
et consulter les informations mémorisées:
List li=new List(nbligne,multiSelect); //déclare et initialise une liste
li.addItem(String s); //ajoute l’élément s à la fin de la liste li
li.addItem(String s,int indice); //ajouter l’élément à la position indice
li.delItem(int indice); //supprime l’élément qui est à la position indice
li.delItems(int id1,int id2); //supprime les éléments entre id1 et id2
li.clear(); // efface complètement le contenu de la liste
li.countItems(); //retourne le nombre d’éléments de la liste
li.getItem(indice); //retourne une chaine de caractères représentant le contenu
de l’élément à la position indice
li.select(indice); //sélectionne l’élément à la position indice
li.setMultipleSelections(); // retourne un booléen true si la sélection multiple
est autorisée, false sinon
…
Prof: R. EL AYACHI
22
3. Composants de l’interface graphique

23. 5. Zones de saisie:
Pour recueillir les saisies de l’utilisateur dans une applet, le
package awt propose la classe TextField. Par définition, le champ
de texte se limite à une seule ligne. Il est généralement associé à
un bouton qui sert à confirmer la saisie.
les quatre constructeurs disponibles sont:
TextField(): déclare un objet de la classe TextField
TextField(int): déclare un objet TextField et fixe le nombre
maximum de caractères à saisir
TextField(String): déclare un objet TextField et fixe un texte
par défaut
TextField(String,int): déclare un objet TextField et fixe un texte par
défaut et le nombre maximum de caractères à saisir
Prof: R. EL AYACHI
23
3. Composants de l’interface graphique

24. Lecture d’un champ de texte:
getText(); //retourne la chaine de caractères saisies
getColumns(); //retourne le nombre de caractères prédéfinies
setEchoChar(); //Saisir une information confidentielle (mot de passe par exemple)
Zone de texte multiligne:
La classe java.awt.TextArea permet la saisie multiligne. Les quatre
constructeurs disponibles sont:
TextArea(): déclare un objet de la classe TextArea
TextArea (int nbLignes,int nbColonnes): déclare un objet TextArea et fixe le
nombre de lignes et de colonnes
TextArea(String): déclare un objet TextArea et initialise le contenu
par défaut
TextArea(String,nbLignes,nbColonnes): déclare un objet TextArea, initialise le
contenu et fixe le nombre de lignes et de colonnes
Prof: R. EL AYACHI
24
3. Composants de l’interface graphique

25. Lecture et modification du contenu d’une zone texte:
getText(); //retourne une chaine de caractères qui est le contenu
de la zone
getSelectedText(); //retourne une partie du texte sélectionnée
getColumns(); //retourne le nombre de colonnes
getRows(); //retournele nombre de lignes
insertText(Text,n); //insère la chaîne Text à partir de nème
caractère
Prof: R. EL AYACHI
25
3. Composants de l’interface graphique

26. Lorsqu’on place des composants dans une applet ou une fenêtre
graphique, leur emplacement à l’écran se fait de manière
automatique et d’une façon variable. La disposition des différents
composants dépend de la taille de la fenêtre et de la taille des
autres composants à ajouter.
On peut changer la disposition des différents composants en
utilisant un gestionnaire de mise en page spécifié. Il existe
plusieurs gestionnaires de mise en page, chacun positionnant
différemment les éléments graphiques.
Tous les gestionnaires de mise en page implémentent
l’interface java.awt.LayoutManager. Pour sélectionner un
gestionnaire de mise en page, on utilise la méthode
setLayout(LayoutManager) de la classe Container.
Les gestionnaires de mise en page les plus utilisés sont:
4. Gestionnaire de mise en page
Prof: R. EL AYACHI
26

27. 1. FlowLayout:
La classe FlowLayout (mise en page flot) place les composants
ligne par ligne de gauche à droite. C’est la disposition par défaut,
celle qui sera utilisée si l’on ne choisit pas un autre gestionnaire.
Déclaration d’un objet de la classe FlowLayout:
FlowLayout fl1 = new FlowLayout();
FlowLayout fl2 = new FlowLayout(int); /* orientation des éléments
(CENTER, LEFT et RIGHT)*/
FlowLayout fl3 = new FlowLayout(int,int,int); /* 1ier
argument
définit l’orientation, le 2ème
argument définit l’espacement
horizontal et le 3ème
argument définit l’espacement vertical.*/
4. Gestionnaire de mise en page
Prof: R. EL AYACHI
27

28. 2. BorderLayout:
Lorsqu’on utilise BorderLayout, on peut placer les éléments dans 5
zones différentes: North, South, East, West et Center.
Déclaration d’un objet de la classe BorderLayout:
BorderLayout bl1 = new BorderLayout();
BorderLayout bl2 = new BorderLayout(int,int); /* le 1ier
argument
définit l’espacement horizontal et le 2ème
argument définit
l’espacement vertical entre les composants*/
4. Gestionnaire de mise en page
Prof: R. EL AYACHI
28

29. 3. GridLayout:
La classe GridLayout organise tous les composants d’un conteneur
en grille (lignes et colonnes). Le même espace est affecté à tous
les composants. Lorsqu’on instancie GridLayout, on doit spécifier
le nombre de lignes et de colonnes. Les éléments sont ajouités
dans la grille de gauche à droite, de haut en bas.
Déclaration d’un objet de la classe GridLayout:
GridLayout gl1 = new GridLayout(int,int); /* le 1ier
argument
définit le nombre de lignes et le 2ème
argument définit le nombre
de colonnes*/
GridLayout gl2 = new GridLayout(int,int,int,int); /* les deux
derniers arguments spécifient l’espacement horizontal et
vertical des composants*/
4. Gestionnaire de mise en page
Prof: R. EL AYACHI
29

30. 4. GridBagLayout:
La classe GridBagLayout est la plus puissante des gestionnaires de mise
en page, mais elle est également la plus difficile à utiliser. La grille est
divisée en cellules égales. Mais pour faciliter les ajustements, un
composant peut occuper plusieurs cellules de la grille. On introduit par
ailleurs un objet de la classe BridBagConstraints qui donne des
indications de positionnement et de dimension à l’objet GridBagLayou.
Variables d’instance pour manipuler un objet GridBagLayout
gridx et gridy: elles contiennent les coordonnées de l’origine de la grille
gridwidth et gridheight: elles définissent combien de cellules va occuper un
composant
GridBagConstraints.REMAINDER: spécifie que le prochain composant inséré va
être le dernier de la ligne ou de la colonne courante
GridBagConstraints.RELATIVE: utilisé pour placer un composant après le dernier
composant d’une ligne ou d’une colonne
4. Gestionnaire de mise en page
Prof: R. EL AYACHI
30

31. Déclaration des objets de GridBagLayout et GridBagConstraints
GridBagLayout gbl = new GridBagLayout();
GridBagConstraints gbc = new GridBagConstraints();
4. Gestionnaire de mise en page
Prof: R. EL AYACHI
31

32. Pour mettre en service les différents composants déjà vu
(boutons, listes, …), il faut toujours les incorporer dans un objet
d’une classe dérivée de la classe abstraite Container. Les
conteneurs les plus utilisés sont: Panel et Frame.
1. Panel:
Le conteneur Panel est un panneau qui sert essentiellement à
ranger les composants. La classe Panel est simple, elle ne contient
qu’un seul constructeur et une seule méthode add().
Panel p = new Panel(); // définit un nouveau panneau
add(p); // intègre le panneau p dans un autre conteneur
Un panneau peut lui-même contenir d’autres conteneurs. Ainsi
des panneaux peuvent être emboités.
5. Conteneurs
Prof: R. EL AYACHI
32

33. 2. Frame:
Une frame ou encadrement permet de créer une fenêtre à
l’extérieur de l’applet qui s’exécute comme une application
indépendante.
La classe Frame contient deux constructeurs:
Frame f = new Frame(); /* création d’une fenêtre
d’encadrement invisible*/
Frame f = new Frame(String); /* création d’une fenêtre
d’encadrement invisible avec un nom de la fenêtre*/
5. Conteneurs
Prof: R. EL AYACHI
33

34. Les interactions de l’utilisateurs avec l’interface (par exemple
cliquer sur la souris, taper sur une touche du clavier, presser un
bouton,…) sont appelés événements. On dit que l’on « traite un
événement » lorsqu’on prend en compte celui-ci et que l’on
exécute des actions en conséquence. La méthode qui traite
l’événement est également appelée gestionnaire d’événement.
La classe java.awt.Event est capable de mémoriser tous les
paramètres relatifs à un événement.
Les réactions aux événements utilisateur dans un programme java
sont gérées par des programmes à l’écoute (Listener). Ces
programmes doivent implémenter l’interface EventListener
(auditeurs d’événements) ou des interfaces qui héritent de
EventListener (par exemple ActionListener). On appellera
« adaptateur » toute instance d’une classe implémentant une
interface héritée de EventListener.
6. Evénements et actions
Prof: R. EL AYACHI
34

35. L’interface ActionListener déclare une seule méthode:
public void actionPerformed(ActionEvent)
L’ajout d’un programme à l’écoute impose deux instructions:
-La classe doit importer le packaje java.awt.event qui contient les
classes d’écoute (import java.awt.event.*;)
- La classe doit utiliser l’instruction implements pour déclarer
qu’elle utilisera une ou plusieurs intrfaces d’écoute. (par exemple:
public class Evenement extends java.applet.Applet implements
Actionlistener)
Les interfaces EventListener permettent à un composant
d’interface graphique utilisateur de générer des événements
utilisateur.
Le tableau ci-dessous est une synthétique des événements et des
« listeners »:
6. Evénements et actions
Prof: R. EL AYACHI
35

36. 6. Evénements et actions
Prof: R. EL AYACHI
36
Evénement Composant Listener Adapteur Méthodes
ActionEvent Button
List
MenuItem
TextField
ActionListener ActionPerformed(ActionEvent)
ItemEvent Checkbox
CheckboxMenuItem
Coice
List
ItemListener ItemStateChanged(ItemEvent)
WindowEvent Dialog
Frame
WindowListener
WindowAdapter
WindowClosing(WindowEvent)
WindowCOpenedWindowEvent)
WindowConified(WindowEvent)
WindowDeiconified(WindowEvent)
WindowActived(WindowEvent)
WindowDesactived(WindowEvent)
ComponentEvent Dialog
Frame
ComponentListener ComponentMoved(ComponentEvent)
ComponentHidden(ComponentEvent)
ComponentResized(ComponentEvent)
ComponentShown(ComponentEvent)
AdjustementEvent Scrollbar AdjustementListener QdjustementValueChanged(AdjustementEvent)

37. 6. Evénements et actions
Prof: R. EL AYACHI
37
MouseEvent Canvas
Dialog
Frame
Panel
Window
MouseListener
MouseAdapter
MousePressed(MouseEvent)
MouseReleased(MouseEvent)
KeyEvent Component KeyListener
KeyAdapter
KeyPressed(KeyEvent)
KeyReleased(KeyEvent)
KeyTyped(KeyEvent)
ContainerEvent Container ContainerListener ComponentAdded(ContainerEvent)
ComponentRemoved(ContainerEvent)
TextEvent TextComponent TextListener TextValueChanged(TextEvent)

38. Réaliser un éditeur:
Exercice
Prof: R. EL AYACHI
38

39. Chapitre 4
Prof: R. EL AYACHI
39
Package java.swing

40. Swing est apparu à partir de la version java1.2. Sa librairie est très
puissante, ses composants sont très évolués (arbres, tables,…).
Mais l’exécution est assez lente.
Contrairement à AWT, les composants Swing ont un aspect
indépendant du système sur lequel les applications sont utilisées.
On y retrouve les composants classiques comme les boutons, les
listes, les cases à cocher, …etc, mais aussi un grand nombre de
nouveaux composants. L’apparence de ces composants est
complètement différents de celles de AWT.
Swing ajoute aux 4 gestionnaires de placement de l’AWT 4 autres
gestionnaires de placement: deux sont intégrés à des composants
(ScrollPaneLayout et ViewportLayout) et ne sont pas utilisables
indépendamment de leur composant respectif, et deux s’utilisent
comme ceux de l’AWT: BoxLayout et OverlayLayout, en liaison
avec un conteneur.
1. Possibilités de java.awt
Prof: R. EL AYACHI
40

41. Swing est éclaté en plusieurs packages. En voici un échantillon:
- javax.swing: Le plus haut niveau du package Swing. Il contient des Composants,
des Adaptateurs, des Modèles par défaut et des interfaces.
- javax.swing.border: contient les classes et les interfaces pour dessiner des
bordures autour des composants
- javax.swing.colorchooser: contient les classes et les interfaces utilisées par le
composant JColorChosser
- javax.swing.event: contient les types d’événements et gestionnaires spécifiques
en plus de ceux de java.awt.evnt
- javax.swing.table: contient les classes et les interfaces utilisées par JTable
- javax.swing.text: contient les classes et les interfaces gérant les composants
textuels éditables ou non
- javax.swing.text.html: fournit la classe HTMLEditorKit et des classe de support
pour la création d’éditeurs HTML
- javax.swing.tree: contient les classes et les interfaces utilisées par JTree
- javax.swing.undo: fournit des classes avec des capacités d’utiliser java comme
éditeur de textes
2. Package javax.swing
Prof: R. EL AYACHI
41

42. Swing ne remplace pas AWT. Il continue à utiliser les classes Color, Graphics,
Toolkit, Font, FontMetrics et les classes de placement de L’AWT, par contre il
n’utilise pas ses composants.
Swing fournit des composants qui viennent en remplacement des composants
AWT et on ajoute de nouveaux. Au total, Swing fournit plus de 40 composants.
Tous les composants de Swing commencent par un J (ex: Jbutton, Jlabel, …).
Les composants Swing sont définis dans le paquet javax.swing et ses sous-
paquets javax.swing.text pour les composants gérant du texte et
javax.swing.table pour ce qui concerne les tableaux.
Tous les composants ci-dessous dérivant de la classe java.awt.Container ce sont
aussi tous des conteneurs.
- Etiquette: JLabel
- Bouton: JButton, JRadioButton
- Case à cocher: JCheckBox
- Champ de texte: JTextField, JPasswordField
- Zone de texte: JTextArea
- Editeur de texte: JEditorPane, JTextPane
3. Principaux composants
Prof: R. EL AYACHI
42

43. - Liste: JList
- Liste de choix: JComboBox
- Arbre: JTree
- Tableau: JTtable, JTableHeader
- Curseur: JSlider
- Barre de défilement: JScrollBar
- Barre de progression: JProgressBar
- Barre d’outils: JToolBar
- Barre de menus: JMenuBar
- Menu: Jmenu, JPopupMenu
- Elément de menu: JMenuItem, JRadioButtonMenuItem, JCheckBoxMenuItem
- Sélectionneur de fichiers: JFileChooser
- Sélectionneur de couleurs: JColorChooser
- Bulle d’aide: JToolTip
- Séparateur: JSeparator
3. Principaux composants
Prof: R. EL AYACHI
43

44. Les conteneurs sont les objets dans les quels sont
incorporés les composants. On peut citer:
JFrame, JDialog, JScrollPane, JTabbedPane, JSplitPane…
4. Principaux conteneurs
Prof: R. EL AYACHI
44

45. 4. Principaux conteneurs
Prof: R. EL AYACHI
45
import javax.swing.*;
Import java.awt.*;
class TestJFrame extends Jframe
{
TestJFrame()
{
super( Une application );″ ″
Container cp=getContentPane();
JLabel label =new JLabel( Hello″
,SwingConstants.CENTER);″
cp.add(label,BorderLayout.CENTER);
}
public static void main(String[] arg)
{
JFrame f = new TestJFrame();
f.setBounds(200,200,150,100);
f.setVisible(true);
}
}

46. Pour décorer les composants, Swing dispose de la classe ImageIcon et des classes
qui dérivent de la classe AbstractBorder.
Un objet de type ImageIcon permet de charger une image au format GIF ou JPEG
à partir d’un fichier ou d’une URL. L’icône obtenue peut ensuite être ajoutée à un
JLabel , par exemple:
ImageIcon test = new ImageIcon( ./image1.gif );″ ″
JLabel etq1 = new JLabel(test);
Il existe 8 types de cadres prédéfinis:
- BevelBorder: cadre 3D qui peut être en creux ou en bosse
- CompoundBorder: cadre composite formé de plusieurs cadres élémentaires
- EmptyBorder: cadre vide, sert à réserver de la place
- EtchedBorder: cadre ayant la forme d’un sillon
- LineBorder: cadre formé d’une simple ligne d’épaisseur donnée
- MatteBorder: cadre formé d’un pavage d’icônes
- SoftBevelBorder: cadre 3D avec coins arrondis
- TitledBorder: cadre supportant un titre
5. Eléments décoratifs
Prof: R. EL AYACHI
46

47. Un cadre est crée à l’aide d’un objet de type BorderFactory spécialisé dans la
fabrication des cadres:
Border cadre = BorderFactory.createLineBorder(Color.black);
et associé à un composant grâce à la méthodfe setBorder();
JButton b = new Jbutton( ON/OF );″ ″
b.setBorder(cadre);
5. Eléments décoratifs
Prof: R. EL AYACHI
47

48. Réaliser une simple calculatrice:
Exercice
Prof: R. EL AYACHI
48