Académique Documents
Professionnel Documents
Culture Documents
Youssef BERAICH
ENS – Tétouan
2010/2011
1
Généralités
Une interface graphique est un ensemble de
composants graphiques permettant à un
utilisateur de communiquer avec un logiciel.
Les éléments graphiques de l'interface java
sont définis dans le paquetage AWT (Abstract
Window Toolkit).
AWT est une librairie de classes graphiques
s'exécutant sans recompilation sur tout
ordinateur disposant d'un interpréteur JVM.
L'apparence diffère selon système
d'exploitation, mais il existe une autre
librairie appelée Swing autonome qui ne
dépend pas du SE.
2
Les éléments de AWT
AWT comporte :
des composants (Component) parmi
lesquels on distingue deux types :
Les conteneurs : Containers
Les widgets
des gestionnaires de mise en page
(LayoutManager)
Un mécanisme de gestion d'événements
3
La classe Component (Composant graphique)
4
hiérarchie des classes dérivées de Component
hiérarchie des classes dérivées de Component
java.awt.Component
java.awt.Button
java.awt.Canvas
java.awt.Checkbox
java.awt.Choice
java.awt.Container
java.awt.Panel
Applet
java.applet.
java.awt.Window
java.awt.Dialog
java.awt.FileDialog
java.awt.Frame
java.awt.Label
java.awt.List
java.awt.Scrollbar
java.awt.TextComponent
java.awt.TextArea
java.awt.TextField
6
Les composants prédéfinis
Les boutons (de classe Button) : un programme
déclenche une action quand l'utilisateur clique sur
un bouton.
7
Les composants prédéfinis
Les composants de classe Choice (appelés aussi
Combo box ou Drop down list dans d'autres
environnements) : Ce type de composant propose
à l'utilisateur de faire un choix parmi un certains
nombres de chaînes de caractères affichées dans
une liste déroulante.
Les listes (de classe List) : ce sont des
composants qui permettent par simple clic, de
sélectionner ou de désélectionner une ou plusieurs
chaînes de caractères affichées dans une
9
Les Canvas
Les composants dérivés de la classe
Canvas :
Si les composants prédéfinis ne satisfont
pas un de vos besoins, vous devez
utiliser cette classe comme super classe
pour créer vos propres composants que
vous dessinez en utilisant les méthodes
de la classe Graphics.
10
Les Containers
Contrairement aux autres composants, les
containers sont utilisés pour contenir
d'autres composants de n'importe quelle
catégorie ou pour afficher directement des
dessins fabriqués avec les méthodes de la
classe Graphics.
Les containers se subdivisent en deux sous
catégories qui héritent toutes deux de la
classe abstract Container :
containers de type fenêtre Window
Les containers de classe Panel
11
containers de type fenêtre
Les containers de type fenêtre (de classe
Window ou ses dérivées)
Les fenêtres sont des zones d'affichage
indépendantes les unes des autres.
Parmi les fenêtres, on distingue:
les boites de dialogue (de classe Dialog)
comportant un cadre et un titre
les fenêtres de classe Frame comportant un
cadre, un titre, un menu éventuel, un pointeur
de souris propre,... (et correspondant aux
fenêtres que vous avez l'habitude d'utiliser).
12
Les containers de classe Panel
Les containers de classe Panel :
Ce type de containers est une zone
d'affichage occupant tout ou partie d'une
fenêtre.
Notamment, la classe Applet dérive de
Panel et permet d'afficher des
composants ou un dessin dans une
fenêtre d'un navigateur.
13
Gestionnaires de placement (LayoutManager)
16
Absence de Layout
Les composants sont rangé en fonction de leur
position et dimension définies explicitement
dans le programme:
17
FlowLayout
Ce gestionnaire
dispose les
composants les uns à
la suite des autres,
sur une même ligne.
Lorsqu’une ligne ne
possède plus three
suffisamment de one
two
place, l’affichage se
poursuit sur la ligne
suivante.
On peut imposer une
four
taille à un composant five
en utilisant la
méthode
setPreferredSize. À
qui on fournit un objet
de type Dimension.
18
FlowLayout
Lors de la construction d ’un gestionnaire
FlowLayout, on peut spécifier un
paramètre d’alignement d’une ligne de
composants par rapport aux bords
verticaux de la fenêtre. Pour cela, on
utilise l’une des constantes entières
suivantes :
FlowLayout.LEFT
FlowLayout.RIGHT
FlowLayout.CENTER
19
Le gestionnaire FlowLayout : affichage
20
BorderLayout
L’emplacement est choisi lors de l’appel de
la méthode add en utilisant une des
constantes symboliques suivantes:
BorderLayout.NORTH
BorderLayout.SOUTH
BorderLayout.EAST
BorderLayout.WEST
BorderLayout.CENTER
Le gestionnaire par défaut est le
gestionnaire Borderlayout.
La taille des composants n’est pas
respectée.
21
Le gestionnaire BorderLayout : Affichage
22
GridLayout
Ce gestionnaire
permet de
disposer les
différents one two three
composants
suivant une grille
four
régulière, chaque five six
composant
occupant une
cellule.
23
Le gestionnaire GridLayout : Affichage
24
CardLayout
Les composants sont présentés un par un
comme un paquet de cartes vu de
dessus. On ne voit que le composant du
dessous.
Des méthodes permettent de basculer
entre les différents composants.
25
GridBagLayout
Les composants sont rangés dans des
cases de même taille disposées en lignes
et en colonnes mais en tenant compte
des contraintes: tel composant doit être
le dernier de sa ligne par exemple; tel
autre composant occupe deux cases, etc.
26
Gestion des événements
Les événements sont classés par thèmes donnant lieu
chacun à une classe. Voici quelques unes de ces classes :
composant générateur signification
enfoncement et relâchement de
KeyEvent Component
touche
entrée et sortie du curseur de
FocusEvent Component
souris
TextField,
TextEvent modification du texte
TextArea
iconification, activation,
WindowEvent Window
ouverture, fermeture
Gestion des événements : Hierarchie
Gestion des événements : Principe
Les composants Swing créent des événements,
soit directement, soit par une action de
l'utilisateur sur le composant. Ces événements
peuvent déclencher une action exécutée par
d'autre(s) composant(s).
Un composant qui crée des événements est appelé
source. Le composant source délègue le traitement
de l'événement au composant auditeur.
Un composant qui traite un événement est appelé
auditeur (listener)
Un composant auditeur doit s'inscrire auprès du
composant source des événements qu'il veut
traiter.
L'événement L'interface Listener
interface XxxListener{
class XxxEvent extends java.util.EventObject
void traiter( XxxEvent
{ public Xxx(Object source){ super(source);}
e);
...}
}
ActionEvent
interface ActionListener{
void actionPerformed(ActionEvent e);
}