Chapitre

Java Avancé

3
Interface graphique
(Awt, Swing)

2014 - 2015 1
 Java : Interface graphique
Java : un langage indépendant des plateformes (portable)
un même programme doit pouvoir être utilisé dans des
environnements (matériel et OS) différents sans
recompilation.
Nécessité d'offrir une API pour les interfaces graphiques indépendante elle
Java Avancé

aussi des plateformes

Classes et interfaces java
Modèle de gestion des événements
exemple : une classe TextField pour définir un champ de
saisie de texte
TextField(String content)
TextField()
void setText(String content)
String getText()...
2014 - 2015 2
 Deux stratégies
Problème : les systèmes de gestion d'interface utilisateur (GUI Graphical
User Interface systems) sont très différents les uns des autres :
X Window + motif
X Window + gtk
Java Avancé

MacOS X
MS Windows
...

Deux stratégies possibles :

faire une utilisation maximale du système graphique cible
faire une utilisation minimale du système graphique cible

2014 - 2015 3
 1ére stratégie (1/2)

Utilisation maximale du système graphique sous-jacent

L'objet TextField délègue la plupart de ses tâches à un composant

natif.
Le programmeur java utilise un objet TextField
Java Avancé

Objet TextField délègue à une classe adaptateur dépendant de

l'OS :
MotifTextField, GTKTextField, WindowsTextField,
MacOSTextField ....
Le système graghique natif réalise le plus gros du travail

2014 - 2015 4
 1er stratégie (2/2)

Avantages / désavantages
(+) apparence et le comportement (look and feel) des interfaces Java
identique à celui d'applications "ordinaires"
(+) pas besoin de réimplémenter des composants existants
Java Avancé

(-) ne permet de ne fournir que les composants disponibles sur toutes

les plateformes
(-) difficile de garantir un comportement identique sur toutes les
plateformes
Choix adopté pour JAVA AWT
AWT Abstract Window Toolkit
packages java.awt.* présents dans Java depuis version 1.0.
conception pas toujours très judicieuse (cf les évolutions de
awt entre version 1.0 et 1.1 de Java)

2014 - 2015 5
 2éme stratégie (1/2)

Utilisation minimale du système graphique sous-jacent

Utiliser des éléments natifs uniquement pour
opérations de base
Ouvrir une fenêtre, dessiner des lignes/du texte, gestion
primitive des événements
Java Avancé

Réaliser tout le reste en Java

L'objet TextField s'affiche en dessinant des lignes,...

C'est le choix adopté par SWING

packages javax.swing.* dans JDK depuis version 1.2

2014 - 2015 6
 2éme stratégie (2/2)

Avantages / désavantages
(+) facilité d'éviter les différences entre plateformes
(+) n'importe quel nouveau composant d'interface est
immédiatement disponible sur toutes les plateformes
Java Avancé

(-) besoin de ré-implémenter tous les composants

d'interface
(-) les applications java n'ont pas le même look and
feel que les applications "ordinaires"
(-) lenteur ?

2014 - 2015 7
 Les objets graphiques
3 niveaux
Haut niveau
Définir une fenêtre
JApplet, JDialog, JFrame, JWindow
Java Avancé

Niveau intermédiaire
Pour composer la fenêtre
JPanel, JScrollPane, JSplitPane, …
Niveau inférieur
Les éléments de base
JButton, JCheckBox, JTextField, JTextArea, …

2014 - 2015 8
 Exemple simple
import javax.swing.*; Importer le package
public class DisplayFrame {
public static void main (String[] args) {
Créer un objet
graphique
JFrame f = new JFrame("FrameDemo");
//… components are added to its content frame.
Java Avancé

f.setSize(300,200); Définir la taille

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}
}
afficher

2014 - 2015 9
 Top-Level
Les composants top-level possèdent un content pane qui contient
tous les composants visibles d’un top-level
Un composant top-level peut contenir une barre de menu
Java Avancé

2014 - 2015 10
 JFrame: Composer
Ajouter un composant dans Content Pane de JFrame

JFrame f = new JFrame("A Frame");

JButton b = new JButton("Press");
JPanel cp = (JPanel)f.getContentPane();
Java Avancé

cp.add(b)

ou JFrame f = new JFrame("A Frame");

JButton b = new JButton("Press");
f.getContentPane().add(b)

ou JFrame f = new JFrame("A Frame");

JButton b = new JButton("Press");
f.add(b)
2014 - 2015 11
 Ajouter des composants dans une
fenêtre
import javax.swing.*;
public class DisplayFrame {
public static void main (String[] args) { Haut niveau
JFrame f = new JFrame("FrameDemo");
Composante
JLabel label = new JLabel("Hello World");
de base
Java Avancé

JPanel p = (JPanel)f.getContentPane();
p.add(label); Niveau
f.setSize(300,200); //alternative: f.pack(); intermédiaire
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}
}

2014 - 2015 12
 Composer une fenêtre
Créer une fenêtre (1)
Créer un ou des composants intermédiaires (2)
Pour JFrame, un JPanel est associé implicitement
(ContentPane)
Java Avancé

Créer des composants de base (3)

Insérer (3) dans (2)

Insérer (2) dans (1) (s’ils ne sont pas déjà associés)

Afficher

2014 - 2015 13
 Composant de base
JButton
JCheckBox
JRadioButton
JComboBox
Jlist
Java Avancé

Jmenu
Jslider
JTextField
Jlabel
JProgressBar
JToolTip
Jtree, Jtable.
JTextArea, JTextPane, JEditorPane

2014 - 2015 14
Java Avancé Swing components: Illustration

2014 - 2015 15
 Composants intermédiaires
Utilisés pour organiser ou positionner d’autres composants (de base)
JPanel utilisé pour regrouper d’autres composants
JScrollPane fournir une vue avec scroll bars
JSplitPane divise en 2 composants
Java Avancé

Exemple: ajouter 2 boutons dans un Panel

JPanel p = new JPanel();

p.add(new JButton("on"));
p.add(new JButton("off"));

2014 - 2015 16
 JPanel

Le JPanel est le conteneur intermédiaire le plus neutre

On ne peut que choisir la couleur de fond
Java Avancé

Quelques méthodes de JPanel:

public JPanel();
public Component add(Component comp);
public void setLayout(LayoutManager lm);

2014 - 2015 17
 JScrollPane

Un JScrollPane est un conteneur qui offre des ascenseurs, il

permet de visionner un composant plus grand que lui
Java Avancé

Quelques méthodes:
public JScrollPane(Component comp);
public void setCorner(String key,Component comp);
2014 - 2015 18
 JSplitPane

Un JSplitPane est un panel coupé en deux par une barre de

séparation. Un JSplitPane accueil deux composants.
Java Avancé

Quelques Méthodes :
public JSplitPane(int ori, Component comp, Component c);
public void setDividerLocation(double pourc);

2014 - 2015 19
 JTabbedPane

Un JTabbedPane permet d’avoir des onglets

Java Avancé

Quelques méthodes :
public JTabbedPane();
public void addTab(String s, Icon i, Component c, String s);
public Component getSelectedComponent();

2014 - 2015 20
 JToolBar

Une JToolBar est une barre de menu

Java Avancé

Quelques Méthodes :
public JToolBar();
public Component add(Component c);
public void addSeparator();

2014 - 2015 21
 Conteneurs et composants
Les deux conteneurs les plus courants sont le JFrame et le JPanel.
Un JFrame représente une fenêtre de haut niveau avec un titre,
une bordure et des angles de redimensionnement.
La plupart des applications utilisent au moins un JFrame
comme point de départ de leur interface graphique.
Java Avancé

Un JPanel n'a pas une apparence propre et ne peut pas être utilisé
comme fenêtre autonome.
Les Panels sont créés et ajoutés aux autres conteneurs de la
même façon que les composants tels que les boutons
Les Panels peuvent ensuite redéfinir une présentation qui leur
soit propre pour contenir eux-mêmes d'autres composants.

2014 - 2015 22
 Gestionnaire de présentation (1)

A chaque conteneur est associé un gestionnaire de présentation

(layout manager)
Le gestionnaire de présentation gère le positionnement et le
(re)dimensionnement des composants d’un conteneur.
Java Avancé

Le ré-agencement des composants dans un conteneur a lieu lors

de :
la modification de sa taille,
le changement de la taille ou le déplacement d'un des
composants.
l'ajout, l'affichage, la suppression ou le masquage d'un
composant.
Les principaux gestionnaires de présentation sont : FlowLayout,
BorderLayout, GridLayout, CardLayout, GridBagLayout

2014 - 2015 23
 Gestionnaire de présentation (2)

Tout conteneur possède un gestionnaire de présentation par

défaut.
Tout instance de Container référence une instance de
LayoutManager.
Il est possible d'en changer grâce à la méthode setLayout().
Java Avancé

Les gestionnaires de présentation par défaut sont :

Le BorderLayout pour Window et ses descendants (Frame,
Dialog, …)
Le FlowLayout pour Panel et ses descendants (Applet, etc.)

Une fois installé, un gestionnaire de présentation fonctionne

"tout seul" en interagissant avec le conteneur.

2014 - 2015 24
 FlowLayout (1)

Le FlowLayout est le plus simple des managers de l'AWT

Gestionnaire de présentation utilisé par défaut dans les Panel si
aucun LayoutManager n'est spécifié.
Un FlowLayout peut spécifier :
Java Avancé

une justification à gauche, à droite ou centrée,

un espacement horizontal ou vertical entre deux

composants.

Par défaut, les composants sont centrés à l'intérieur de la

zone qui leur est allouée.

2014 - 2015 25
 FlowLayout (2)
La stratégie de disposition du FlowLayout est la suivante :

Respecter la taille préférée de tous les composants

contenus.

Disposer autant de composants que l'on peut en faire tenir

Java Avancé

horizontalement à l'intérieur de l'objet Container.

Commencer une nouvelle rangée de composants si on ne

peut pas les faire tenir sur une seule rangée.

Si tous les composants ne peuvent pas tenir dans l'objet

Container, ce n'est pas géré (c'est-à-dire que les composants
peuvent ne pas apparaître).

2014 - 2015 26
 FlowLayout (3)

OK Ouvrir Redimensionnement Ouvrir Fermer

OK
Fermer
Java Avancé

plus visible

OK Ouvrir Redimensionnement
OK Ouvrir Fermer
Fermer

2014 - 2015 27
 FlowLayout (4)

Redimensionnement
Java Avancé

Redimensionnement

2014 - 2015 28
 FlowLayout (5)

Redimensionnement
Java Avancé

Redimensionnement

2014 - 2015 29
 BorderLayout (1)
BorderLayout divise son espace de travail en cinq zones
géographiques : North, South, East, West et Center.
Les composants sont ajoutés par nom à ces zones (un seul
composant par zone).
Exemple
Java Avancé

add("North", new Button("Le bouton nord !"));

Si une des zones de bordure ne contient rien, sa taille est
0.

NORTH

WEST CENTER EAST

SOUTH
2014 - 2015 30
 BorderLayout (2)
public class EssaiBorderLayout extends JFrame
{
private JButton b1,b2,b3,b4, b5;
public EssaiBorderLayout() {
setLayout(new BorderLayout());
Java Avancé

b1 = new JButton ("Nord"); b2 = new JButton ("Sud");

b3 = new JButton ("Est"); b4 = new JButton ("Ouest");
b5 = new JButton ("Centre");
this.add(b1, BorderLayout.NORTH);
this.add(b2 , BorderLayout.SOUTH);
this.add(b3, BorderLayout.EAST);
this.add(b4, BorderLayout.WEST);
this.add(b5, BorderLayout.CENTER);
}
public static void main (String args []) {
EssaiBorderLayout essai = new EssaiBorderLayout();
essai.pack (); essai.setVisible(true) ;
}}

2014 - 2015 31
 BorderLayout (3)

N N
Java Avancé

Redimensionnement
O C E
O C E
S

2014 - 2015 32
 BorderLayout (4)

Redimensionnement
Java Avancé

Redimensionnement

2014 - 2015 33
 GridLayout (1)
Le GridLayout dispose les composants dans une grille.
Découpage de la zone d'affichage en lignes et en colonnes qui
définissent des cellules de dimensions égales.
Chaque composant à la même taille
Java Avancé

quand ils sont ajoutés dans les cellules le remplissage s ’effectue

de gauche à droite et de haut en bas.
Les 2 paramètres sont les rangées et les colonnes.
Construction d'un GridLayout : new GridLayout(3,2);

nombre de lignes nombre de colonnes

2014 - 2015 34
 GridLayout (2)

import java.awt.*;
public class AppliGridLayout extends Frame
{
public AppliGridLayout()
{
Java Avancé

super("AppliGridLayout");
this.setLayout(new GridLayout(3,2));
for (int i = 1; i < 7; i++)
add(new Button(Integer.toString(i)));
this.pack();
this.show();
}

public static void main(String args[])

{
AppliGridLayout appli = new AppliGridLayout();
}
}
2014 - 2015 35
 GridLayout (3)
Lors d’un redimensionnement les composants changent tous de
taille mais leurs positions relatives ne changent pas.

1 2 1 2
Java Avancé

Redimensionnement
3 4 4
3
5 6
5 6

Redimensionnement

2014 - 2015 36
 CardLayout
Le CardLayout n'affiche qu'un composant à la fois :

les composants sont considérées comme empilées, à la façon

d'un tas de cartes.
La présentation CardLayout permet à plusieurs composants de
Java Avancé

partager le même espace d'affichage de telle sorte que seul l'un

d'entre eux soit visible à la fois.
Pour ajouter un composant à un conteneur utilisant un
CardLayout il faut utiliser add(String cle, Component monComposant)
Permet de passer de l ’affichage d ’un composant à un autre en
appelant les méthodes first, last, next, previous ou show

Exemple sur Eclipse

2014 - 2015 37
 GridBagLayout (1)
Le gestionnaire GridBagLayout fournit des fonctions de
présentation complexes
basées sur une grille dont les lignes et les colonnes sont de
tailles variables.
permet à des composants simples de prendre leur taille
Java Avancé

préférée au sein d'une cellule, au lieu de remplir toute la

cellule.
permet aussi l'extension d'un même composant sur plusieurs
cellules.
Le GridBagLayout est compliqué à gérer.
Dans la plupart des cas, il est possible d’éviter de l’utiliser en
associant des objets Container utilisant des gestionnaires
différents.

Exemple sur Eclipse

2014 - 2015 38
 Mise en forme complexe

super("AppliComplexeLayout");
setLayout(new BorderLayout());
Panel pnorth = new Panel();
pnorth.add(b1); pnorth.add(b2);
pnorth.add(b3); pnorth.add(b4);
Java Avancé

this.add(pnorth,BorderLayout.NORTH);

Panel pcenter = new Panel();

pcenter.setLayout(new GridLayout(2,2));
pcenter.add(gr1); pcenter.add(gr2);
pcenter.add(gr3); pcenter.add(gr4);
this.add(pcenter,BorderLayout.CENTER);

Panel psouth = new Panel();

psouth.setLayout(new FlowLayout());
psouth.add(ch); psouth.add(tf);
this.add(psouth, BorderLayout.SOUTH);

2014 - 2015 39
 D’autres gestionnaires?
On peut imposer à un objet « container » de n’avoir pas de
gestionnaire en fixant son LayoutManager à la valeur null
Frame f = new Frame(); f.setLayout(null);
A la charge alors du programmeur de positionner chacun des
composants « manuellement » en indiquant leur position
Java Avancé

absolue dans le repère de la fenêtre.

C’est à éviter, sauf dans des cas particuliers,.

Il est possible d’écrire ses propres LayoutManager…

2014 - 2015 40
 Récapitulatif
FlowLayout
Flux : composants placés les uns derrière les autres
BorderLayout
Ecran découpé en 5 zones (« North », « West », « South »,
« East », « Center »)
Java Avancé

GridLayout
Grille : une case par composant, chaque case de la même
taille
CardLayout
« Onglets » : on affiche un élément à la fois
GridBagLayout
Grille complexe : plusieurs cases par composant

2014 - 2015 41
 Les événements graphiques (1)
L'utilisateur effectue
une action au niveau de l'interface utilisateur (clic souris,
sélection d'un item, etc)
alors un événement graphique est émis.
Java Avancé

Lorsqu'un événement se produit

il est reçu par le composant avec lequel l'utilisateur interagit
(par exemple un bouton, un curseur, un champ de texte,
etc.).
Ce composant transmet cet événement à un autre objet, un
écouteur qui possède une méthode pour traiter l’événement
cette méthode reçoit l’objet événement généré de façon à traiter
l'interaction de l'utilisateur.

2014 - 2015 42
 Les événements graphiques (2)
La gestion des événements passe par l'utilisation d'objets
"écouteurs d'événements" (les Listener) et d'objets sources
d'événements.
Un objet écouteur est l'instance d'une classe implémentant
l'interface EventListener (ou une interface “fille”).
Java Avancé

Une source d'événements est un objet pouvant recenser des

objets écouteurs et leur envoyer des objets événements.

Lorsqu'un événement se produit,

la source d'événements envoie un objet événement
correspondant à tous ses écouteurs.
Les objets écouteurs utilisent alors l'information contenue
dans l'objet événement pour déterminer leur réponse.

2014 - 2015 43
 Les événements graphiques (3)
import java.awt.*;
import java.awt.event.*;

class MonAction implements ActionListener {

public void actionPerformed (ActionEvent e) {
System.out.println ("Une action a eu lieu") ;}
Java Avancé

public class TestBouton {

public TestBouton(){
JFrame f = new JFrame ("TestBouton");
JButton b = new JButton ("Cliquer ici");
f.add (b) ;
f.pack (); f.setVisible (true) ;
b.addActionListener (new MonAction ());}

public static void main(String args[]) {

TestBouton test = new TestBouton();}
}
2014 - 2015 44
 Les événements graphiques (4)
Les écouteurs sont des interfaces

Donc une même classe peut implémenter plusieurs interfaces

écouteur.
Par exemple une classe héritant de Frame implémentera les
Java Avancé

interfaces MouseMotionListener (pour les déplacements souris) et

MouseListener (pour les clics souris).

Chaque composant AWT/SWING est conçu pour être la source

d’un ou plusieurs types d'événements particuliers.
Cela se voit notamment grâce à la présence dans la classe de
composant d'une méthode nommée addXXXListener().

2014 - 2015 45
 Les événements graphiques (5)

L’objet événement envoyé aux écouteurs et passé en paramètres

des fonctions correspondantes peut contenir des paramètres
intéressants pour l'application.
Java Avancé

Par exemple, getX() et getY() sur un MouseEvent retournent les

coordonnées de la position du pointeur de la souris.

Une information généralement utile quelque soit le type

d’événement est la source de cet événement que l’on obtient
avec la méthode getSource().

2014 - 2015 46
Java Avancé
Les événements graphiques (6)

2014 - 2015 47
 Catégories d'événements graphiques (1)

Plusieurs types d'événements sont définis dans le package

java.awt.event.

Pour chaque catégorie d'événements, il existe une interface qui

doit être définie par toute classe souhaitant recevoir cette
Java Avancé

catégorie d’événements.

Cette interface exige aussi qu'une ou plusieurs méthodes

soient définies.

Ces méthodes sont appelées lorsque des événements

particuliers surviennent.

2014 - 2015 48
 Catégories d'événements graphiques (2)

Catégorie Nom de l’interface Méthodes

Action ActionListener actionPerformed (ActionEvent)
Item ItemListener itemStateChanged (ItemEvent)
Mouse MouseMotionListener mouseDragged (MouseEvent)
mouseMoved (MouseEvent)
Java Avancé

Mouse MouseListener mousePressed (MouseEvent)

mouseReleased (MouseEvent)
mouseEntered (MouseEvent)
(MouseEvent)
mouseExited
mouseClicked
Key KeyListener keyPressed (KeyEvent)
keyReleased (KeyEvent)
keyTyped (KeyEvent)
Focus FocusListener focusGained (FocusEvent)
focusLost (FocusEvent)

2014 - 2015 49
 Catégories d'événements graphiques (3)

Adjustment AdjustmentListener adjustmentValueChanged

(AdjustmentEvent)
Component ComponentListener componentMoved
(ComponentEvent)componentHiddent
(ComponentEvent)componentResize
Java Avancé

(ComponentEvent)componentShown
(ComponentEvent)
Window WindowListener windowClosing (WindowEvent)
windowOpened (WindowEvent)
windowIconified (WindowEvent
windowDeiconified (WindowEvent)
windowClosed (WindowEvent)
windowActivated (WindowEvent)
windowDeactivated (WindowEvent)
Container ContainerListener componentAdded (ContainerEvent)
componentRemoved(ContainerEvent)
Text TextListener textValueChanged (TextEvent)

2014 - 2015 50
 Catégories d'événements graphiques (4)

ActionListener
Action (clic) sur un bouton, retour chariot dans une zone de
texte, « tic d’horloge » (Objet Timer)

WindowListener
Java Avancé

Fermeture, iconisation, etc. des fenêtres

TextListener
Changement de valeur dans une zone de texte

ItemListener
Sélection d’un item dans une liste

2014 - 2015 51
 Catégories d'événements graphiques (5)

MouseListener
Clic, enfoncement/relâchement des boutons de la souris, etc.

MouseMotionListener
Java Avancé

Déplacement de la souris, drag&drop avec la souris, etc.

AdjustmentListener
Déplacement d'une échelle

ComponentListener
Savoir si un composant a été caché, affiché …

2014 - 2015 52
 Catégories d'événements graphiques (6)

ContainerListener
Ajout d'un composant dans un Container
Java Avancé

FocusListener
Pour savoir si un élément a le "focus«

KeyListener
Pour la gestion des événements clavier

2014 - 2015 53
 Catégories d'événements graphiques (7)

import java.awt.*;
import java.awt.event.*;
public class EssaiActionEvent1 extends JFrame
implements ActionListener Implémentation de
{ l'interface ActionListener
public static void main(String args[])
Java Avancé

{EssaiActionEvent1 f= new EssaiActionEvent1();} On enregistre

public EssaiActionEvent1() l’écouteur d’evt
{ action auprès de
super("Utilisation d’un ActionEvent"); l’objet source "b"
JButton b = new JButton("action");
b.addActionListener(this); Lorsque l'on clique
add(BorderLayout.CENTER,b);pack();show(); sur le bouton dans
} l ’interface, le titre
public void actionPerformed( ActionEvent e ) de la fenêtre change
{
setTitle("bouton cliqué !");
}}

2014 - 2015 54
 Catégories d'événements graphiques (8)

public class EssaiActionEvent2 extends JFrame

implements ActionListener
{ private JButton b1,b2;
public static void main(String args[])
Les 2 boutons ont le
{EssaiActionEvent2 f= new EssaiActionEvent2();}
même écouteur (la
public EssaiActionEvent2(){
Java Avancé

fenêtre)
super("Utilisation d’un ActionEvent");
b1 = new JButton("action1"); e.getSource()"
b2 = new JButton("action2"); renvoie l'objet source
b1.addActionListener(this); de l’événement. On
b2.addActionListener(this); effectue un test sur
add(BorderLayout.CENTER,b1); les boutons (on
add(BorderLayout.SOUTH,b2); compare les
pack();show(); } références)
public void actionPerformed( ActionEvent e ) {
if (e.getSource() == b1) setTitle("action1 cliqué");
if (e.getSource() == b2) setTitle("action2 cliqué");
}}

2014 - 2015 55
 Catégories d'événements graphiques (9)

import java.awt.*; import java.awt.event.*;

public class WinEvt extends Frame
implements WindowListener
{ Implémenter cette
public static void main(String[] args) { interface impose
WinEvt f= new WinEvt();} l’implémentation de
Java Avancé

public WinEvt() { bcp de méthodes

super("Cette fenêtre se ferme");
addWindowListener(this); La fenêtre est son
pack();show();} propre écouteur
public void windowOpened(WindowEvent e){}
public void windowClosing(WindowEvent e) WindowClosing() est
{System.exit(0);} appelé lorsque l'on
public void windowClosed(WindowEvent e){} clique sur la croix de
public void windowIconified(WindowEvent e){} la fenêtre
public void windowDeiconified(WindowEvent e){} "System.exit(0)"
public void windowActivated(WindowEvent e){} permet de quitter une
public void windowDeactivated(WindowEvent e){} } application java

2014 - 2015 56
 Un autre exemple
public PlayBalloon() {
setTitle("Balloon");
setLayout(new FlowLayout());

grow = new Button("Grow");

import java.awt.*;
import java.awt.event.*;
public class PlayBalloon extends Frame
implements ActionListener,
WindowListener
{ exit = new Button("Exit");
private Button grow, shrink, exit;
private Balloon myBalloon;
add(grow);
grow.addActionListener(this);
shrink = new Button("Shrink");
add(shrink);
shrink.addActionListener(this);
add(exit);
exit.addActionListener(this);

public static void main(String[] args) { myBalloon = new Balloon(20, 50, 50);
PlayBalloon f = new PlayBalloon();
f.setSize(300, 300); this.addWindowListener(this);
f.setVisible(true);
} } // fin constructeur PlayBalloon
 Réactions Ballon
public void actionPerformed(ActionEvent event) { class Balloon {
if (event.getSource() == grow) private int diameter;
myBalloon.changeSize(10); private int xCoord, yCoord;
if (event.getSource() == shrink)
myBalloon.changeSize(-10); Balloon (int initialDiameter, int
repaint(); initialX, int initialY) {
if (event.getSource() == exit) diameter = initialDiameter;
System.exit(0); xCoord = initialX;
} yCoord = initialY;
public void windowClosing(WindowEvent event) { }
System.exit(0);
} public void changeSize (int
public void windowIconified(WindowEvent event) {} change) {
public void windowOpened(WindowEvent event) {} diameter = diameter+change;
public void windowClosed(WindowEvent event) {} }
public void windowDeiconified(WindowEvent event) {}
public void windowActivated(WindowEvent event) {} public void display (Graphics g) {
public void windowDeactivated(WindowEvent event) {} g.drawOval (xCoord, yCoord,
diameter, diameter);
}
public void paint (Graphics g) { }
myBalloon.display(g);
}
}
 Les adapteurs (1)
Les classes « adapteur » permettent une mise en œuvre simple
de l'écoute d'événements graphiques.

Ce sont des classes qui implémentent les écouteurs

d'événements possédant le plus de méthodes, en définissant
Java Avancé

un corps vide pour chacune d'entre elles.

Plutôt que d'implémenter l'intégralité d'une interface dont une
seule méthode est pertinente pour résoudre un problème
donné, une alternative est de sous-classer l'adapteur
approprié et de redéfinir juste les méthodes qui nous
intéressent.
Par exemple pour la gestion des événements fenêtres...

2014 - 2015 59
 Les adapteurs (2)
Solution en implémentant l’interface
class Terminator implements WindowListener
{
public void windowClosing (WindowEvent e) {System.exit(0);}
public void windowClosed (WindowEvent e) {}
Java Avancé

public void windowIconified (WindowEvent e) {}

public void windowOpened (WindowEvent e) {}
public void windowDeiconified (WindowEvent e) {}
public void windowActivated (WindowEvent e) {}
public void windowDeactivated (WindowEvent e) {}
}

Solution en utilisant un WindowAdapter

class Terminator extends WindowAdapter
{
public void windowClosing (WindowEvent e) {System.exit(0);}
}

2014 - 2015 60
 Les adapteurs (3)
Il existe 7 classes d'adapteurs (autant que d'interfaces
d'écouteurs possédant plus d'une méthode) :
ComponentAdapter
ContainerAdapter
Java Avancé

FocusAdapter
KeyAdapter
MouseAdapter
MouseMotionAdapter
WindowAdapter

2014 - 2015 61
 Les adapteurs (4)
En pratique, et notamment avec la classe WindowAdapter, on
utilise très souvent une classe anonyme

Frame f = new Frame("Machin")

Java Avancé

f.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e)
{
System.exit(0);
} });

2014 - 2015 62
 Les composants atomiques
Un composant atomique est considéré comme étant une entité
unique.
Java propose beaucoup de composants atomiques:
boutons, CheckBox, Radio
Combo box
Java Avancé

List, menu
TextField, TextArea, Label
FileChooser, ColorChooser,
...

2014 - 2015 63
 Les boutons

Java propose différent type de boutons:

• Le bouton classique est un JBouton.
Java Avancé

• JCheckBox pour les case à cocher

• JRadioBouton pour un ensemble de bouton
• JMenutItem pour un bouton dans un menu
• JCheckBoxMenuItem
• JRadioButtonMenuItem
• JToggleButton Super Classe de CheckBox et Radio
2014 - 2015 64
 JButton
JButton
C'est un composant d'interface utilisateur de base de type
"appuyer pour activer".
Un objet de la classe Button est une source d’ActionEvent
Java Avancé

Les écouteurs associés à des objets de la classe Button

doivent implémenter interface ActionListener
Il n’y a qu’une méthode dans l’interface ActionListener, c’est
la méthode public void actionPerformed(ActionEvent e).

JButton b = new JButton ("Sample") ;

add (b) ;
b.addActionListener (...) ;

2014 - 2015 65
 JComboBox

Un JComboBox est un composant permettant de faire un

choix parmi plusieurs propositions.
Java Avancé

Quelques méthodes:
public JComboBox(Vector v);
public JComboBox(ComboBoxModel c);
Object getSelectedItem();
void addItem(Object o);
2014 - 2015 66
 JList

Une JList propose plusieurs éléments rangés en colonne.

Une JList peut proposer une sélection simple ou multiple
Les JList sont souvent contenues dans un srolled pane
Java Avancé

Quelques méthodes:
public JList(Vector v);
public JList( ListModel l);
Object[] getSelectedValues();

2014 - 2015 67
 JSlider

Les JSlider permettent la saisie graphique d’un nombre

Un JSlider doit contenir les bornes max et min
Java Avancé

Quelques méthodes:
public JSlider(int min ,int max, int value);
public void setLabelTable(Dictionary d);

2014 - 2015 68
 JTextField

Un JTextField est un composant qui permet d’écrire du

texte.
Un JTextField a une seul ligne contrairement au JTextArea
Java Avancé

Le JPasswordField permet de cacher ce qui est écrit

Quelques méthodes:
public JTextField(String s);
public String getText();
2014 - 2015 69
 JLabel

Un JLabel permet d’afficher du texte ou une image.

Un JLabel peut contenir plusieurs lignes et il comprend les
Java Avancé

tag HTML.

Quelques méthodes:
public JLabel(String s);
public JLabel(Icon i);

2014 - 2015 70
 Les menus

Si on a une barre de menu JMenuBar, on ajoute des JMenu dans la

barre.
Les JMenu et le JPopupMenu ont le même mode de fonctionnement,
créer des JMenuItem et les ajouter.
Java Avancé

Ex:
menuBar = new JMenuBar();
setJMenuBar(menuBar);
menu = new JMenu("A Menu");
menuBar.add(menu);
menuItem = new JMenuItem("menu item");
menu.add(menuItem);

2014 - 2015 71
 JTree

Un JTree permet d’afficher des informations sous forme d’arbre. Les nœuds
de l’arbre sont des objets qui doivent implanter l’interface MutableTreeNode.
Une classe de base est proposée pour les nœuds : DefaultMutableTreeNode.
Pour construire un arbre il est conseillé de passer par la classe TreeModel qui
Java Avancé

est la représentation abstraite de l’arbre.

Pour construire un arbre:

rootNode = new DefaultMutableTreeNode("Root");
treeModel = new DefaultTreeModel(rootNode);
tree = new JTree(treeModel);
childNode = new DefaultMutableTreeNode ("Child");
rootNode.add(childNode);

2014 - 2015 72
 JFileChooser

Un JFileChooser permet de sélectionner un fichier en parcourant

l’arborescence du système de fichier.
Java Avancé

Ex :
JFileChooser fc = new JFileChooser();
int returnVal = fc.showOpenDialog(aFrame);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File file = fc.getSelectedFile();
}
2014 - 2015 73
 JColorChooser

Un JColoChooser permet de choisir une couleur

Java Avancé

Une méthode :
public static Color showDialog(Component c , String title , Color initialColor);

2014 - 2015 74
 JProgressBar

Un JProgressBar permet d’afficher une barre de

progression.
Java Avancé

Quelques méthodes :
public JProgressBar();
public JProgressBar(int min, int max);
public void setValue(int i);

2014 - 2015 75
 JTextArea
La zone de texte est un dispositif d'entrée de texte multi-
lignes, multi-colonnes avec éventuellement la présence ou
non de « scrollbars » (barres de défilement) horizontal et/ou
vertical.
Il peut être ou non éditable.
Java Avancé

Méthode setText(), getText() et append() (pour ajouter du

texte à la fin d ’un texte existant déjà dans le TextArea)

JTextArea t = new JTextArea ("Hello !", 4, 30,TextArea.SCROLLBARS_BOTH);

add(t);

Valeur constante
Texte par défaut mis précisant la
dans le TextArea présence ou
Nombre de colonnes l’absence de
Nombre de lignes (en nbre de caractères)
2014 - 2015 « scrollbar » 76
 ImageIcon
La classe ImageIcon et l’interface Icon
Les objets de cette classe permettent de définir des icônes à
partir d’images (gif, jpg, etc.) qui peuvent être ajoutés au
classique texte d'un JLabel, d'un JButton, etc.
Java Avancé

Icon monIcone = new ImageIcon("Image.gif");

// Un JLabel
JLabel monLabel = new JLabel("Mon Label");
monLabel.setIcon(monIcone);
monLabel.setHorizontalAlignment(JLabel.RIGHT);

// Un JButton
JButton monBouton = new JButton("Mon bouton", monIcone);

2014 - 2015 77
 Quelques composants
JTextPane
un éditeur de texte qui permet la gestion de texte formaté, le
retour à la ligne automatique (word wrap), l'affichage
d'images.
JPasswordField
Java Avancé

un champ de saisie de mots de passe : la saisie est invisible

et l'affichage de chaque caractère tapé est remplacé par un
caractère d'écho (* par défaut).
JEditorPane
un JTextComponent pour afficher et éditer du code HTML 3.2 et
des formats tels que RTF.

2014 - 2015 78
 Exemple de JEditorPane
import javax.swing.*;
import java.awt.*;
public class EditeurWEB {
public static void main(String[] args)
{
JFrame monFrame = new JFrame ("Mon Frame");
Java Avancé

monFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
try {
JEditorPane monEditeur = new
JEditorPane("http://www.google.fr");
Container panneauContenu = monFrame.getContentPane();
panneauContenu.setLayout(new FlowLayout());
panneauContenu.add(monEditeur);
monFrame.pack();
monFrame.show();
}
catch (Exception e) {System.out.println(e.getMessage());};
} }

2014 - 2015 79
 Bordures
Des bordures peuvent être dessinées autour de tous
composants graphiques. Swing en définit 9 types :
AbstractBorder : ne fait rien
BevelBorder : une bordure 3D en surépaisseur ou en creux
CompoundBorder : permet de composer des plusieurs
Java Avancé

bordures
EmptyBorder
EtchedBorder
LineBorder : bordures d'une seule couleur)
MatteBorder
SoftBevelBorder : une bordure 3D aux coins arrondis
TitledBorder : une bordure permettant l'inclusion d’une
chaîne de caractères

2014 - 2015 80
Java Avancé
Bordures

2014 - 2015 81
Java Avancé JOptionPane

String response =
JOptionPane.showInputDialog(frame, “Message Type”);
int value = convertToInt(response);

2014 - 2015 82
Java Avancé JOptionPane

int response =
JOptionPane.showConfirmDialog(frame, “Take over the world?”,
“The Brain”, JOptionPane.YES_NO_OPTION);
if (response == YES_OPTION) …

2014 - 2015 83