Applets

ECRITURE D’APPLETS EN
JAVA AVEC SWING

1 Ecriture d’une applet
Une applet est une application devant être placée dans un fichier HTML On doit donc l’insérer dans la page
HTML en lui allouant de la place (comme on le fait pour une image). Elle peut ensuite être exécutée par un
navigateur.
1.1 Intégration de l’applet dans une page HTML

L’applet est désignée dans la page HTML par la balise <APPLET> on précise le nom et le chemin de l’applet
ainsi que la place qui lui est réservée à l’écran et la façon dont elle l’occupe :
<applet code = nomDuFichierDApplet.class codebase = nomDuCheminDuFichierDApplet
width = largeur height = hauteur >
</applet>
hauteur et largeur définissent les tailles en pixels disponibles pour les affichages de l’applet, ils peuvent aussi
être exprimés en % de la place disponible.
codebase peut être omis ou remplacé par "." s'il n'y a pas de sous répertoire pour l'applet.
On peut passer des paramètres à l’applet en les désignant dans la page HTML. Pour cela on utilise la balise
<PARAM NAME="nomDuParamètre" VALUE="valeurDuParamètre">
Ces paramètres sont des chaînes de caractères qui peuvent être récupérées par la méthode getParameter décrite
plus loin (voir 1.4.1).
Exemple de page HTML incluant une applet contenue dans le fichier Anime.class placé dans le répertoire applets
et à laquelle on transmet un paramètre Couleur de valeur rouge et un paramètre Vitesse de valeur 50 (cette valeur
n’est par un entier et devra être convertie) :
<HTML>
<HEAD>
<TITLE> Essai d'Applet : Animation paramétrée </TITLE>
</HEAD>
<BODY>
<P>
<APPLET CODE="Parametres.class" CODEBASE="applets" WIDTH="100%" HEIGHT=200 ALIGN=middle>
<PARAM NAME="Couleur" VALUE="rouge">
<PARAM NAME="Vitesse" VALUE="50"> </APPLET>
</P>
</BODY>
</HTML>
Depuis la version 4 de HTML il est préférable d'utiliser la balise object plutôt que la balise APLLET. Ceci se
fait comme suit:
<object
codetype="application/java-archive"
classid="java:Parametres.class"
codebase="applets"
width="100%" height="200" align=middle
standby="texte affiché pendant que l'applet se charge"
>
<PARAM NAME="Couleur" VALUE="rouge">
<PARAM NAME="Vitesse" VALUE="50"> </APPLET>
On peut mettre ici un texte qui sera affiché si l'applet ne démarre pas
</object>
Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

1
1.2 Exécution de l’applet
L’applet est constituée d’une classe publique héritant de la classe prédéfinie JApplet contenue dans la
bibliothèque javax.swing. Cette classe donnera, après compilation, le fichier nomDuFichierDApplet.class qui
sera référencé dans le texte HTML.
Le navigateur appellera 6 méthodes de cette classe :
la méthode public void init() lorsqu’il charge l’applet (chargement de la page)
la méthode public void start() chaque fois que l’applet devient ou redevient visible
la méthode public void stop()chaque fois que l’applet devient ou redevient invisible
la méthode public void destroy() lorsqu’il arrête l’applet
la méthode public void paint(Graphics) chaque fois qu’il affiche l’applet
Il conviendra de surcharger certaines de ces méthodes pour obtenir de l’applet le comportement souhaité.
Le tableau suivant décrit l’ordre des appels se produisant lors des principales situations que peut rencontrer le
navigateur :
méthode appelée init stop start paint destroy

Situation envisagée
Lancement du navigateur sur la page contenant l’applet 1 2 3
Entrée dans la page contenant l’applet 1 2 3
Sortie de la page contenant l’applet 1 2
Restauration du navigateur (réactivation de l'icône) 1
Fermeture du navigateur 1 2
Mise en plein écran de la fenêtre 1
Mise en premier plan de la fenêtre 1(1)
(1) L’appel de paint n’a lieu que si cette mise en premier plan rend visible une partie de l’applet qui était
cachée.
1.3 Communications avec l’utilisateur

La classe JApplet hérite de la classe Container de AWT (voir 2.1.1), on peut donc mettre dans une applet tous
les composants habituels d’interface graphique (boutons, listes, zones graphiques ...).
Toutefois, pour d’évidentes raisons de sécurité, une applet ne peut établir de connexion sur le réseau avec
d’autres machines que celle qui l’héberge ni utiliser de fichier ailleurs que sur cette même machine.
L’applet s’exécute dans l’emplacement que lui a réservé le navigateur qui est vu par l’applet comme une fenêtre
l’est par une application. Chaque fois que le navigateur doit rafraîchir le contenu de cet emplacement il fait appel
à la méthode paint de l’applet. Il faudra donc parfois surcharger cette méthode :
public void paint(Graphics fenetre) {
// tout ce qui doit être affiché dans la fenêtre se fait ici en utilisant les possibilités de la classe Graphics
}
Remarque : Lorsque l'on utilise une interface dans l'applet, la surcharge de paint est inutile puisque la méthode
paint héritée de JApplet se charge de l'affichage de l'interface.
1.4 Les autres moyens de communication

Une applet dispose de plusieurs moyens de communication avec le navigateur et avec la machine qui l’héberge.
Elle utilise en particulier pour cela des objets de classe URL permettant d’accéder à des informations (fichiers,
pages HTML, sons ...) au travers du réseau.
1.4.1 Relations de l’applet avec son environnement

Principales méthodes liées à l'environnement :
URL getCodeBase() retourne l’URL de l’applet
URL getDocumentBase() retourne l’URL du document qui contient l’applet
String getAppletInfo() retourne des informations sur l'applet (auteur ...). Cette méthode peut être redéfinie
de façon à lui faire retourner les informations souhaitées.

2
String getParameter(String) retourne la valeur du paramètre d'appel de l'applet dont le nom est désigné par
le paramètre de getParameter. Des paramètres peuvent êtres transmis à l’applet par le navigateur, ils sont
indiqués dans le texte HTML avec l’invocation de l’applet (voir 1.1).
showStatus(String etat) affiche le paramètre sur la barre d’état du navigateur
AppletContext getAppletContext() retourne le contexte dans lequel se situe l'applet qui décrit
l'environnement dans lequel évolue l'applet. En général ce contexte n'est pas utilisé en tant que tel mais
sert de moyen d'accès à d'autres éléments (voir 1.4.3)
1.4.2 Images et sons

Pour les images on utilise la classe ImageIcon. Elle permet de récupérer des images que l'on peut ensuite placer
dans divers composants. Ses principales méthodes sont :
ImageIcon(String) qui construit l'image à partir d'un fichier .gif ou .jpg dont on passe le nom en paramètre.
ImageIcon(URL) qui construit l'image à partir d'un fichier .gif ou .jpg dont on passe l'URL en paramètre.
ImageIcon(Image) qui construit l'image à partir d'un objet Image.
Image getImage() qui crée un objet de classe Image contenant l'image
int getIconWidth() qui retourne la largeur de l'image
int getIconHeight() qui retourne la hauteur de l'image
void paintIcon(Component,Graphics,int,int) qui dessine l'image dans un composant dont on précise le
contexte graphique. Les deux derniers paramètres sont les coordonnées du coin supérieur gauche où
placer l'icône dans le composant.
Remarque : Pour les images l'URL utilisée est en général obtenue à partir de celle où se trouve l'applet. On peut
donc la créer en utilisant : new URL(getCodeBase(), chemin-et-nom_du_fichier_image);
Bien entendu il faudra prévoir un try catch pour traiter l'exception de classe MalformedURLException liée au
new.
Pour les sons on utilise la classe AudioClip. Elle permet de récupérer des sons que l'on peut ensuite jouer. Les
fichiers son utilisables sont ceux au format SUN (.au), Windows (.wav), Macintosh (.aif) et midi (.mid). Ses
principales méthodes sont :
AudioClip getAudioClip(URL) retourne le son contenu dans le fichier spécifié par l’URL donnée en
paramètre. On peut ensuite jouer ce son en utilisant sa méthode play().
AudioClip getAudioClip(URL,String) retourne le son situé dans l’URL donnée en premier paramètre et
dont le nom est spécifié en second paramètre. On peut ensuite jouer ce son en utilisant sa méthode play().
AudioClip newAudioClip(URL) retourne le son spécifié par l’URL donnée en paramètre. Cette méthode
présente l'avantage d'être statique c'est à dire de pouvoir être appelée par n'importe quel objet et pas
seulement par un objet de classe Applet ou dérivée. On l'appelle par : Applet.newAudioClip On peut
ensuite jouer ce son en utilisant sa méthode play().
play(URL) déclenche la diffusion du son spécifié par l’URL donnée en paramètre.
play(URL,String) déclenche la diffusion du son situé dans l’URL donnée en premier paramètre et dont le
nom est spécifié en second paramètre.
Remarque : Pour les sons l'URL utilisée est en général obtenue à partir de celle où se trouve l'applet. On peut
utiliser : getAudioClip(getCodeBase(), chemin-et-nom_du_fichier_son);
1.4.3 Changement de page HTML

Une applet peut remplacer la page HTML actuellement affichée (celle donc dans laquelle elle se situe) par une
autre. Pour ce faire on utilise la méthode :
showDocument(URL lieu, String nom) affiche la page HTML située dans l’URL donnée en premier
paramètre et dont le nom est spécifié en second paramètre à la place de la page courante. Le second
paramètre peut prendre les valeurs suivantes :
"_self" pour affichage dans la même fenêtre
"_blank" pour affichage dans une nouvelle fenêtre sans nom
"_xxx" pour affichage dans la fenêtre de nom xxx. Si elle n'existe pas, elle sera créée.
Attention, cette méthode n’appartient par à la classe JApplet mais à la classe AppletContext (voir 1.4.1). Il
faut donc l’appeler par : getAppletContext().showDocument(URL lieu, String nom).

3
Component
2 Interfaces graphiques avec SWING
Container SWING offre toute une panoplie de classes pour la création
d’interfaces graphiques. Chacun des objets de ces classes est
susceptible de réagir à des événements provenant de la souris ou du
JComponent clavier. Lorsque l’on utilise de telles classes il faut prévoir
d’importer les bibliothèques javax.swing.* et javax.swing.event.*
JComboBox en début de programme.
JLabel
2.1 Réalisation d’une interface graphique
JList Une applet hérite de la classe Container ce qui lui permet de se
placer dans une page HTML. On placera ensuite dans cette zone des
JMenubar
composants comme des boutons, des zones de saisie etc. Tous ces
JPopupMenu composants appartiennent à des classes héritant de la classe
JComponent dont nous allons maintenant décrire les principales
JScrollbar méthodes.
JProgressbar
2.1.1 Les classes Component et JComponent
JSlider C’est de là que dérivent tous les composants de l’interface
JToolBar
graphique. La classe JComponent hérite de Component et propose
quelques méthodes supplémentaires. Les principales méthodes de
JToolTip ces classes sont les suivantes :
JColorChooser Celles propres à la classe Component :
JTextComponent
boolean isShowing() indique si le composant est visible à
l ’écran
void setVisible(boolean) rend le composant visible on non à
JTextArea l’écran
JTextField
void requestFocus() rend le composant actif (les saisies au
clavier le concernent). Il faut que le composant soit visible.
JFileChooser boolean isEnabled() indique si le composant est sensible aux
événements
JAbstractButton void setEnabled(boolean) permet de rendre le composant
sensible ou pas aux événements
JToggleButton Color getForeground() retourne la couleur utilisée pour
dessiner et écrire dans ce composant
void setForeground(Color) définit la couleur de tracé
JCheckBox
Color getBackground() retourne la couleur de fond de ce
JRadioButton composant
void setBackground(Color) définit la couleur de fond
JButton Font getFont() retourne la fonte de caractères utilisée par ce
composant
JMenuItem
void setFont(Font) définit la fonte de caractères
Cursor getCursor() retourne le curseur de souris utilisé sur ce
JMenu composant
void setCursor(Cursor) définit le curseur de souris pour ce
JRadioButtonMenuitem
composant
JCheckBoxMenuItem int getWidth() et int getHeight() retournent la largeur et la
hauteur du composant.
void setSize(int , int) définit la taille du composant
int getx() et int gety() retournent les coordonnées de ce composant
void setLocation(int , int) définit la position du composant
Toolkit getToolkit() retourne un objet boîte à outils permettant de gérer les images, les fontes de caractères
etc. (voir 2.2)
Graphics getGraphics() retourne un objet permettant de dessiner (voir 2.2.1)
boolean prepareImage(Image,ImageObserver) provoque le chargement d'une image. Le premier
paramètre une image (par exemple retournée par getImage() voir 2.2.1) et en second le composant qui la
gère (en général c'est celui dont on utilise la méthode prepareImage que l'on désignera donc par this). Ce

4
chargement se fait en parallèle et il peut ne pas être terminé quand on veut utiliser l'image. La valeur de
retour indique si le chargement est ou non terminé.
void repaint() redessine le composant
Celles propres à la classe JComponent :

void setPreferredSize(Dimension) définit la taille préférentielle du composant
Dimension getPreferedSize() retourne la taille préférentielle du composant
void setMinimumSize(Dimension) définit la taille minimale du composant
void setMaximumSize(Dimension) définit la taille maximale du composant
void setToolTipText(String) définit le texte qui sera affiché lorsque la souris passera sur ce composant. Ce
texte disparaît lorsque la souris s'éloigne du composant ou au bout d'un certain délai.
JRootPane getRootPane() retourne l’objet de classe RootPane qui contient ce composant ou null s’il n ‘y en
a pas.
Remarque : se reporter à la documentation de Java pour
en savoir plus sur les classes Dimension, Toolkit et
Cursor. Les classes Font et Color seront décrites plus
loin.
2.1.2 Les composants de l’interface

L'applet (héritée de JApplet) que l’on va définir contiendra en tant que propriétés les noms des composants
d’interface (boutons, zones de texte ou de dessin ...) dont on souhaite disposer.
Il conviendra ensuite de les initialiser et de définir leur disposition. Pour cela, le constructeur de la classe
d’interface devra se charger :
- de créer les objets associés (new)
- de les initialiser par leurs constructeurs ou par tout autre moyen disponible
- de les placer
- de leur associer les actions liées aux événements qu’ils peuvent recevoir
Il se chargera par ailleurs de dimensionner la fenêtre et de la rendre visible à l’écran.
Les principales classes de composants sont les suivants :
JButton : un bouton à cliquer avec un texte
JLabel : juste un titre (un texte non éditable)
JTextField : une zone de texte éditable d’une ligne
JTextArea : une zone de texte éditable multi lignes
JCheckBox : une case à cocher
JComboBox : une liste déroulante
JList : une liste dans laquelle on peut sélectionner un ou plusieurs éléments par double clic
JScrollBar : un ascenseur horizontal ou vertical
JMenubar : une barre de menu
JFileChooser : une fenêtre de dialogue permettant de choisir un fichier
JSlider : un curseur linéaire
JProgressBar : une barre indiquant la progression d’une opération
Remarque : Cette liste n’est pas exhaustive. Il existe aussi des groupes de cases à cocher, des boîtes de dialogue,
des sous menus etc.
Ces composant possèdent les méthodes communes contenues dans la classe JComponent (voir 2.1.1) auxquelles
viennent s’ajouter leurs méthodes propres. Nous allons maintenant en décrire les principales :
2.1.2.1 La classe JButton

Elle permet de définir des boutons sur lesquels on peut cliquer. Ses principales méthodes sont :
JButton(String) construction avec définition du texte contenu dans le
bouton
JButton(ImageIcon) construction avec une icone dans le bouton
JButton(String, ImageIcon) construction avec définition du texte et d’une
icône dans le bouton
String getText() qui retourne le texte contenu dans le bouton
void setText(String) qui définit le texte contenu dans le bouton
void addActionListener(ActionListener) pour associer l'objet qui traitera les clics sur le bouton (voir
2.1.6.3)

5
2.1.2.2 La classe JCheckBox
Elle permet de définir des cases à cocher. Ses principales méthodes sont :
JCheckBox(String) construction avec définition du texte contenu dans la case à
cocher
JCheckBox(String,boolean) construction avec en plus définition de l'état initial de la case à cocher
boolean isSelected() qui retourne l'état de la case à cocher (cochée ou non).
void setSelected(boolean) qui définit l'état de la case à cocher (cochée ou non).
String getText() qui retourne le texte contenu dans la case à cocher
void setText(String) qui définit le texte contenu dans la case à cocher
void addActionListener(ActionListener) pour associer l'objet qui traitera les actions sur la case à cocher
(voir 2.1.6.3)
2.1.2.3 La classe JLabel

Elle permet de définir des textes fixes. Ses principales méthodes sont :
JLabel(String) qui construit le titre avec son contenu
JLabel(Icon) qui construit le titre avec une image comme contenu (le paramètre peut être de classe
ImageIcon)
void setText(String) qui définit le texte
String getText() qui retourne le texte
void setIcon(ImageIcon) qui définit l'image
Icon getIcon() qui retourne l'image sous forme d'un objet de classe Icon. On peut le récupérer dans un objet
de classe ImageIcon en faisant : ImageIcon img = (ImageIcon) label.getIcon()
2.1.2.4 La classe JComboBox

Elle permet de définir des boîtes permettant de choisir une valeur parmi celles proposées. Ses principales
méthodes sont :
JComboBox(Object[]) construction avec définition de la liste. On peut utiliser un tableau de chaînes de
caractères (String) ou de toute autre classe d’objets.
void addItem(Object) qui ajoute une valeur possible de choix
int getSelectedIndex() qui retourne le numéro du choix actuel
Object getSelectedItem() qui retourne l’objet associé au choix actuel. Attention l’objet
retourné est de classe Object, il faudra utiliser l’opérateur de coercition pour le
transformer en sa classe d’origine (String par exemple).
void setSelectedIndex(int) qui sélectionne un élément défini par son numéro
void addActionListener(ActionListener) pour associer l'objet qui traitera les choix faits
(voir 2.1.6.3)
2.1.2.5 La classe JList

Elle permet de définir des listes non déroulantes (pour disposer de listes avec ascenseur il faut faire appel à un
contenant possédant des ascenseurs comme JScrollPane). La sélection dans ces listes peut porter sur 1 ou
plusieurs objets. Ses principales méthodes sont :
JList(Object[]) construction avec définition de la liste. On peut utiliser un tableau de chaînes de caractères
(String) ou de toute autre classe d’objets.
setListData(Object[]) définition de la liste. On peut utiliser un tableau de chaînes de caractères
(String) ou de toute autre classe d’objets.
void setVisibleRowCount(int) qui définit le nombre d’éléments visibles sans ascenseur
int getSelectedIndex() qui retourne le numéro du premier élément sélectionné
int[] getSelectedIndices() qui retourne les numéros des éléments sélectionnés
Object getSelectedValue() qui retourne le premier objet sélectionné. Attention l’objet retourné est de classe
Object, il faudra utiliser l’opérateur de coercition pour le transformer en sa classe d’origine (String par
exemple).
Object[] getSelectedValues() qui retourne les objets actuellement sélectionnés.
void setSelectedIndex(int) qui sélectionne l’élément désigné par son numéro
void setSelectedIndices(int[]) qui sélectionne les éléments désignés par leurs numéros
void clearSelection() qui annulle toutes les sélections
int getModel().getSize() retourne le nombre d'éléments dans la liste
Object getModel().getElementAt(int) retourne l'objet de la liste correspondant au rang donné en paramètre.

6
void addListSelectionListener(ListSelectionListener) pour associer l'objet qui traitera les sélections dans
la liste (voir 2.1.6.3)
Remarque : le constructeur de JList avec un tableau d'objets permet de créer une liste initialisée mais pas de la
modifier dynamiquement. Pour créer une liste modifiable dynamiquement (ajout/suppression d'éléments) il faut
lui associer un contenu sous forme d'un modèle :
DefaultListModel contenu = new DefaultListModel ();
JList listeDynamique = new JList(contenu);
On pourra alors ajouter des éléments à la liste en les ajoutant au modèle par :
contenu.addelement(Object)
ou contenu.insertElementAt(Object,int)
Et en enlever par :
contenu.removeElementAt(int)
ou contenu.removeElement(Object)
2.1.2.6 La classe JScrollBar

Elle permet de définir des ascenseurs horizontaux ou verticaux. Ses principales méthodes sont :
JScrollbar(int,int,int,int,int) qui définit l'ascenseur avec dans l'ordre des paramètres son orientation (on
peut y mettre les constantes JScrollbar.HORIZONTAL ou JScrollbar.VERTICAL), sa position
initiale, le pas avec lequel on le déplace en mode page à page, ses valeurs minimales et maximales.
int getValue() qui retourne la positon actuelle de l'ascenseur
void setValue(int) qui définit la position de l'ascenseur
int getBlockIncrement() qui retourne la valeur utilisée pour le pas
en mode page à page
void setBlockIncrement (int) qui définit la valeur utilisée pour le pas en mode page à page
int getUnitIncrement() qui retourne la valeur utilisée pour le pas unitaire
void setUnitIncrement (int) qui définit la valeur utilisée pour le pas unitaire
int getMaximum() qui retourne la valeur maximale actuelle
void setMaximum (int) qui définit la valeur maximale actuelle
int getMinimum() qui retourne la valeur minimale actuelle
void setMinimum (int) qui définit la valeur minimale actuelle
void addAdjustmentListener(AdjustmentListener) pour associer l'objet qui traitera les déplacements de
l'ascenseur (voir 2.1.6.3)
2.1.2.7 La classe JSlider

Elle permet de définir des curseurs horizontaux ou verticaux gradués. Ses principales méthodes sont :
JSlider(int,int,int,int,int) qui définit l'ascenseur avec dans l'ordre des paramètres son orientation (on peut y
mettre les constantes JSlider.HORIZONTAL ou JSlider.VERTICAL), ses valeurs minimales et
maximales et sa position initiale.
void setMajorTickSpacing(int) qui détermine le nombre d’unités correspondant à un graduation plus
longue.
void setMinorTickSpacing(int) qui détermine le nombre d’unités correspondant à un graduation courte.
void setPaintTicks(boolean) qui détermine si les graduations sont ou non dessinées.
void setPaintTrack(boolean) qui détermine si la piste du curseur est ou non dessinée.
Hashtable createStandardLabels(int,int) qui permet de créer une table d’étiquettes constituée de nombres
entiers. Le premier paramètres est le pas, le second est la valeur de départ. Une telle table pourra être
associée au curseur par sa méthode setLabelTable (la classe Hashtable est une classe directement héritée
de Dictionary).
void setLabelTable(Dictionary) qui associe une table d‘étiquettes aux graduations longues du
curseur
void setPaintLabels(boolean) qui détermine si les valeurs correpondant aux graduations longues
sont ou non écrites.
int getValue() qui retourne la positon actuelle de l'ascenseur
void setValue(int) qui définit la position de l'ascenseur
int getUnitIncrement() qui retourne la valeur utilisée pour le pas unitaire
void setUnitIncrement (int) qui définit la valeur utilisée pour le pas unitaire

7
void addChangeListener(ChangeListener) pour associer l'objet qui traitera les déplacements du curseur
(voir 2.1.6.3)
Le curseur présenté ci contre ici est défini par :

curseur=new JSlider (JSlider.VERTICAL,0,100,80);
curseur.setMajorTickSpacing(10);
curseur.setMinorTickSpacing(2);
curseur.setPaintTicks(true);
curseur.setPaintTrack(true);
curseur.setLabelTable(curseur.createStandardLabels(20,14));
curseur.setPaintLabels(true);
2.1.2.8 La classe JProgressBar

Elle permet de dessiner une barre dont la longueur représente une quantité ou un pourcentage. Ses principales
méthodes sont :
JProgressBar (int,int,int) qui définit la barre avec dans l'ordre des paramètres son orientation (on peut y
mettre les constantes JProgressBar.HORIZONTAL ou JProgressBar.VERTICAL) et ses valeurs
minimales et maximales.
int getValue() qui retourne la positon actuelle de la barre
void setValue(int) qui définit la position de la barre
void addChangeListener(ChangeListener) pour associer l'objet qui traitera les déplacements de la barre
(voir 2.1.6.3)
2.1.2.9 Les classes JTextField et JTextArea

Elles permettent de définir des zones de texte éditable sur une ou plusieurs lignes. Elles ont en commun un
certain nombre de méthodes dont voici les principales :
void copy() qui copie dans le bloc-notes du système la partie de texte sélectionnée
void cut() qui fait comme copy puis supprime du texte la partie sélectionnée
void paste() qui fait copie dans le texte le contenu du bloc-notes du système
String getText() qui retourne le texte contenu dans la zone de texte
void setText(String) qui définit le texte contenu dans la zone de texte
int getCaretPosition() qui retourne la position du curseur d’insertion dans le texte (rang du caractère)
int setCaretPosition(int) qui place le curseur d’insertion dans le texte au rang indiqué (rang du caractère)
int moveCaretPosition(int) qui déplace le curseur d’insertion dans le texte en sélectionnant le texte depuis
la position précédente.
setEditable(boolean) qui rend la zone de texte modifiable ou pas
int getSelectionStart() qui retourne la position du début du texte sélectionné (rang du caractère)
int getSelectionEnd() qui retourne la position de la fin du texte sélectionné (rang du caractère)
void setSelectedTextColor(Color c) qui définit la couleur utilisée pour le texte sélectionné
String getSelectedText() qui retourne le texte sélectionné
void select(int,int) qui sélectionne le texte compris entre les deux positions données en paramètre
void selectAll() qui sélectionne tout le texte
Document getDocument() qui retourne le gestionnaire de document associé à cette zone de texte. C’est ce
gestionnaire qui recevra les événements de modification de texte
void addCaretListener(CaretListener) pour associer l'objet qui traitera les déplacements du curseur de
saisie dans le texte (voir 2.1.6.3)
La classe Document
Prend en charge l’édition de texte. Ses principales méthodes sont :
int getLength() qui retourne le nombre de caractères du document
String getText(int,int) qui retourne la partie du texte qui commence à la position donnée en premier
paramètre et dont la longueur est donnée par le second paramètre
void removeText(int,int) qui supprime la partie du texte qui commence à la position donnée en premier
paramètre et dont la longueur est donnée par le second paramètre

8
void addDocumentListener(DocumentListener) pour associer l'objet qui traitera les modifications du texte
(voir 2.1.6.3)
Remarque : Ces deux dernières méthodes peuvent lever une exception de classe BadLocationException si les
paramètres sont incorrects
La classe JTextField
Elle permet de définir des zones de texte sur une seule ligne modifiables Ses principales
méthodes sont :
JTextField(String) qui la crée avec un contenu initial
JTextField(String,int) qui la crée avec un contenu initial et définit le nombre de colones
void addActionListener(ActionListener) pour associer l'objet qui traitera les modifications du texte
(voir 2.1.6.3)
Remarque : Lorsque l’on saisit du texte dans un tel composant celui-ci adapte sa taille au texte saisi au fur et à
mesure. Ce comportement n’est pas toujours souhaitable, on peut l’éviter en lui définissant une taille
préférentielle par sa méthode setPreferredSize et une taille minimale par sa méthode SetMinimumSize
(voir 2.1.1). On procédera comme suit : texte.setPreferedSize(texte.getPreferredSize()) ;
texte.setMinimumSize(texte.getPreferredSize()) ;
La classe JTextArea
Elle permet de définir des zones de texte sur plusieurs lignes modifiables sans ascenseurs (pour disposer
d’ascenseurs il faut faire appel à un contenant en possédant voir 2.1.3.4). Ses principales méthodes sont :
JTextArea(String) qui crée une zone de texte avec un contenu initial
JTextArea(String,int,int) qui crée une zone de texte avec un contenu initial et
précise le nombre de lignes et de colonnes de la zone de texte
void append(String) qui ajoute la chaîne à la fin du texte affiché
void insert(String,int) qui insère la chaîne au texte affiché à partir du rang donné
void setTabSize(int) qui définit la distance entre tabulations.
void setLineWrap(boolean) qui détermine si les lignes longues doivent ou non
être repliées.
void setWrapStyleWord(boolean) qui détermine si les lignes sont repliées en fin de mot (true) ou pas.
Remarque : Lorsque l’on saisit du texte dans une zone de texte celle-ci adapte sa taille au texte saisi au fur et à
mesure. Ce comportement n’est pas toujours souhaitable, on peut l’éviter en mettant ce composant dans un
JScrollPane pour disposer d’ascenseurs.
2.1.2.8 La classe Canvas

Elle permet de définir des zones de dessin (voir 2.2 pour les aspects graphiques).
2.1.3 Placement des objets

Le placement des composants fait appel à des classes spéciales permettant de définir où se situent les divers
composants de l’interface graphique et comment ils doivent se comporter lorsque l’on modifie les dimensions de
la fenêtre les contenant.
2.1.3.1 Définition de l’interface

Le principe de définition d’une interface est donc le suivant :
1. Faire un dessin de l’interface en y plaçant tous les composants
2. Récupérer le contenant associé à l'applet par la méthode getContentPane de cette dernière
3. Choisir l’objet de placement le plus approprié (BorderLayout, CardLayout, FlowLayout, GridLayout
ou GridBagLayout) (voir 2.1.3.3) et l’associer au contenant par la méthode setLayout du contenant
associé à l'applet (voir 2.1.3.2)
4. A l’aide de la méthode add du contenant, placer les composants (voir 2.1.1) dans les zones définies par
l’objet de placement choisi à l’étape 3 (voir 2.1.3.3). Ceci uniquement pour les composants qui sont
seuls dans une zone.
5. Pour les zones dans lesquelles doivent se trouver plusieurs composants, on mettra un contenant. Ce
contenant est un objet de classe JPanel, JScrollPane, JLayeredPane, JSplitPane ou JTabbedPane
selon le comportement souhaité (voir 2.1.3.4). qui sera lui même associé à un objet de placement.

9
6. Pour chacun de ces contenants, refaire les étapes 3 à 5. Lorsque c’est terminé ajouter ce contenant à son
propre contenant par la méthode add de ce dernier.
7. Continuer jusqu’à ce que tous les composants aient trouvé leur place.
2.1.3.2 Les contenants

Les contenants sont des objets appartenant à des classes qui héritent de Container qui, elle même, hérite de
Component (voir 2.1.1). Les principaux contenants définis par SWING sont JPanel, JscrollPane ,
JLayeredPane, JSplitPane et JTabbedPane.
Dans ces contenants on ajoute les composants de l’interface ou d’autre contenants (voir 2.1.3.1).
Voici les principales méthodes communes à toutes ces classes :

void setLayout(LayoutManager) qui associe au contenant l’objet de placement passé en paramètre.
void add(Component) qui ajoute ce composant au contenant sans désignation de zone lorsque l'objet de
placement n'en a pas besoin (FlowLayout, GridLayout ou GridBagLayout) (voir 2.1.3.5)
void add(Component,Object) qui ajoute ce composant au contenant en utilisant une désignation de zone qui
dépend de l'objet de placement qui a été associé à ce contenant (int pour un BorderLayout)
(voir 2.1.3.5).
void remove(Component) qui enlève ce composant au contenant
void removeAll() qui enlève tous les composants au contenant
Component locate(int,int) qui retourne le composant situé aux coordonnées données en paramètre
La classe JPanel
Elle correspond au contenant le plus simple. Elle offre deux constructeurs :
JPanel() qui se contente de créer l’objet.
JPanel(LayoutManager) qui accepte en paramètre un objet de placement et construit le JPanel associé à cet
objet.
La classe JScrollPane
C’est une version améliorée de JPanel qui possède des ascenseurs de défilement vertical et horizontal. Ses
principales méthodes sont :
JScrollPane() qui crée un JScrollPane vide
JScrollPane(Component) qui crée un JScrollPane contenant un seul composant (celui passé en paramètre).
JScrollPane(int,int) qui crée un JScrollPane vide en précisant le comportement des ascenseurs (voir
ci_dessous).
JScrollPane(Component,int,int) qui crée un JScrollPane contenant un seul composant (celui passé en
paramètre) en précisant le comportement des ascenseurs.
Le premier entier définit le comportement de l’ascenseur vertical, il peut prendre les valeurs :
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED (l’ascenseur n’apparaît que s’il est nécessaire),
JScrollPane.VERTICAL_SCROLLBAR_NEVER (pas d’ascenseur) ou
JScrollPane.VERTICAL_SCROLLBAR_ALWAYS (l’ascenseur est toujours présent).
Le dernier entier définit le comportement de l’ascenseur horizontal, il peut prendre les valeurs :
JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED (l’ascenseur n’apparaît que s’il est
nécessaire), JScrollPane.HORIZONTAL_SCROLLBAR_NEVER (pas d’ascenseur) ou
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS (l’ascenseur est toujours présent).
La classe JLayeredPane
Elle permet de définir des couches superposées. Quand on ajoute un élément à un JLayeredPane, on précise à
quelle profondeur il se situe. Les couches de profondeur moindre cachent les autres. Ses principales méthodes
sont :
void add(Component,Integer) qui ajoute ce composant au contenant dans une couche donnée. Plus le
second paramètre est élevé moins la couche est profonde.
int getLayer(Component) qui retourne le numéro de la couche où se trouve le composant passé en
paramètre.
void setLayer(Component,int) qui déplace le composant dans la couche dont le numéro est passé en second
paramètre.
int lowestLayer() qui retourne le numéro le plus élevé correspondant à une couche occupée.
int highesterLayer() qui retourne le numéro le plus faible correspondant à une couche occupée.

10
La classe JSplitPane
Elle permet de définir deux zones adjacentes avec une barre de séparation pouvant être déplacée à la souris. Ces
zones peuvent être cote à cote ou l’une sous l’autre. Ses principales méthodes sont :
JSplitPane(int) qui construit une JSplitPane avec une indication d’orientation. Le paramètre peut être
JSplitPane.VERTICAL_SPLIT ou JSplitPane.HORIZONTAL_SPLIT
JSplitPane(int,Component,Component) qui construit une JSplitPane avec une indication d’orientation en
premier paramètre (JSplitPane.VERTICAL_SPLIT ou JSplitPane.HORIZONTAL_SPLIT), et les deux
composants à y placer.
Remarque : On peut ajouter à ces deux constructeurs un dernier paramètre booléen qui indique si, lors du
déplacement de la barre de séparation des deux zones, leurs contenus doivent être redessinés en
permanence (true) ou seulement lorsque la barre cessera de bouger (false).
Component getLeftComponent() qui retourne le composant de gauche (ou celui de dessus).
Component getRightComponent() qui retourne le composant de droite (ou celui de dessous).
Component getTopComponent() qui retourne le composant de dessus (ou celui de droite).
Component getBottomComponent() qui retourne le composant de dessous (ou celui de gauche).
int getDividerSize() qui retourne la taille en pixels de la séparation.
int getDividerLocation() qui retourne la position de la séparation (en pixels).
int getMaximumDividerLocation() qui retourne la position maximale possible de la séparation (en pixels).
int getMinimumDividerLocation() qui retourne la position minimale possible de la séparation (en pixels).
int setDividerLocation(double) qui positionne la séparation. La valeur est un réel représentant un
pourcentage de 0.0 à1.0.
void setDividerSize(int) qui définit l’épaisseur de la barre de séparation (en pixels).
La classe JTabbedPane
Elle permet de placer les éléments selon des onglets. Ses principales méthodes sont :
JTabbedPane(int) crée l’objet en précisant où se placent les onglets. Le paramètre peut prendre les valeurs :
JTabbedPane.TOP, JTabbedPane.BOTTOM, JTabbedPane.LEFT ou JTabbedPane.RIGHT.
void addTab(String,Component) ajoute un onglet dont le libellé est donné par le premier paramètre et y
place le composant donné en second paramètre
void addTab(String,ImageIcon,Component) ajoute un onglet dont le libellé est donné par le premier
paramètre et auquel est associée une icône (second paramètre) et y place le composant donné en dernier
paramètre
void addTab(String,ImageIcon,Component,String) ajoute un onglet dont le libellé est donné par le
premier paramètre et auquel est associée une icône (second paramètre) et y place le composant donné en
troisième paramètre. Le dernier est une bulle d’aide qui apparaîtra lorsque la souris passera sur l’onglet.
void insertTab(String,ImageIcon,Component,String,int) insère un onglet dont le libellé est donné par le
premier paramètre et auquel est associée une icône (second paramètre) et y place le composant donné en
troisième paramètre. Le quatrième paramètre est une bulle d’aide qui apparaîtra lorsque la souris passera
sur l’onglet. Le dernier indique la position à laquelle doit être inséré l’onglet.
void removeTabAt(int) qui supprime l’onglet désigné.
void setIconAt(int , ImageIcon) associe une icône à l'onglet désigné
int getSelectedIndex() qui retourne le numéro de l'onglet sélectionné
void setSelectedIndex(int) qui sélectionne l'onglet dont le numéro est passé en paramètre
int getTabCount() qui retourne le nombre d'onglets disponibles.
int indexOfTab(ImageIcon) retourne le premier onglet associé à l'icône passée en paramètre
int indexOfTab(String) retourne le premier onglet associé au nom passé en paramètre
Remarque : les deux méthodes précédentes peuvent lever une exception de classe
ArrayIndexOutOfBoundsException si la position de l’onglet n’est pas correcte.
String getTitleAt(int) qui retourne le libellé de l’onglet désigné

void setTitleAt(int,String) qui définit le libellé de l’onglet désigné.
boolean isEnabledAt(int) qui indique si l’onglet désigné est accessible ou pas.
boolean setEnabledAt(int,boolean) qui rend accessible ou pas l’onglet désigné.
int getTabCount() qui retourne le nombre d’onglets.
int indexOfTab(String) qui retourne le numéro correspondant à l’onglet désigné par son libellé.
void setBackgroundAt(int,Color) qui définit la couleur de fond pour la page correspondant à l’onglet
désigné par le premier paramètre.

11
void setForegroundAt(int,Color) qui définit la couleur de tracé pour la page correspondant à l’onglet
désigné par le premier paramètre.
void addChangeListener(ChangeListener) pour associer l'objet qui traitera les changements d’onglet (voir
2.1.6.3)
2.1.3.3 Les objets de placement

Le placement des composants fait appel à des classes spéciales permettant de définir où se situent les divers
composants de l’interface graphique. Pour cela on fait appel à un objet de l’une des classes disponibles pour
organiser le placement :
BorderLayout pour un placement simple en 5 zones (Nord, sud, Est, Ouest et Centre)
FlowLayout pour un placement ligne à ligne. Dès qu’une ligne est pleine on passe à la suivante.
GridLayout pour un placement en tableau avec une case par élément. Le tableau est rempli ligne par ligne.
GridBagLayout pour un placement en grille avec une ou plusieurs cases par élément.
CardLayout pour un placement en pages superposées dont une seule est visible à la fois.
La classe BorderLayout
Cette classe définit 5 zones. Les composants y sont ajoutés par la méthode add(Component, int) dont le second
paramètre indique dans quelle zone doit être placé le composant. Ce paramètre peut prendre les valeurs :
BorderLayout.NORTH, BorderLayout.SOUTH, BorderLayout.EAST, BorderLayout.WEST ou
BorderLayout.CENTER
La classe FlowLayout
Cette classe permet un placement ligne par ligne. Elle possède un constructeur qui définit la façon dont les
composants seront ajoutés par la suite à l'aide de la méthode add(Component). Ce constructeur accepte trois
paramètres selon le modèle suivant FlowLayout(int,int,int). Le premier paramètre indique comment seront
alignés les composants, il peut prendre les valeur suivantes : FlowLayout.CENTER, FlowLayout.LEFT ou
FlowLayout.RIGHT. Le deuxième paramètre donne l'espacement horizontal entre composants (en pixels). Le
dernier paramètre donne l'espacement vertical entre composants (en pixels).
La classe GridLayout
Cette classe permet un placement sur un tableau. Elle possède un constructeur qui définit les dimensions de ce
tableau et les espacements entre les composants. Ce constructeur accepte quatre paramètres selon le modèle
suivant GridLayout(int,int,int,int). Le premier paramètre est le nombre de lignes du tableau tandis que le
deuxième est le nombre de colonnes du tableau.. Le troisième paramètre donne l'espacement horizontal entre
composants (en pixel). Le dernier paramètre donne l'espacement vertical entre composants (en pixels). Toutes les
cases du tableau ont la même taille (celle déterminée par le composant le plus grand).
Les composants seront ajoutés par la suite à l'aide de la méthode add(Component) qui remplira le tableau ligne
par ligne.
La classe GridBagLayout
Cette classe permet un contrôle plus précis du placement des composants grâce à l'utilisation d'un objet de classe
GridBagConstraints qui permet de définir les règles de placement pour chaque composant. GridBagLayout
permet de placer les composants dans une grille dont les cases sont numérotées de gauche à droite et de haut en
bas à partir de 0. Chaque composant peut occuper une ou plusieurs cases et la taille des cases est ajustée en
fonction des composants qu’elles contiennent. Toutes les cases d’une même ligne ont la même hauteur qui
correspond à la hauteur nécessaire pour placer le composant le plus haut de cette ligne. De même toutes les cases
d’une même colonne ont la même largeur qui correspond à la largeur nécessaire pour placer le composant le plus
large de cette colonne.
Pour placer un composant il faut suivre la procédure suivante :
- appeler la méthode setLayout avec en paramètre le nom de l’objet de placement de classe GridBagLayout
- préparer un objet de classe GridBagConstraints permettant de définir la position, la taille et le
comportement de l’objet à placer
- utiliser la méthode setConstraints de l’objet de placement en lui donnant en paramètre le composant
d’interface graphique à placer et l’objet de classe GridBagConstraints précédemment préparé.
- ajouter ce composant à l’interface graphique par la méthode add
Les objets de la classe GridBagConstraints comportent les champs suivants :

gridx et gridy pour définir les coordonnées de la case en haut à gauche du composant
gridwidth et gridheight pour définir le nombre de cases qu’il occupe horizontalement et verticalement

12
ipadx et ipady pour définir les marges internes du composant
fill pour indiquer dans quelle(s) direction(s) le composant se déforme pour s’adapter à la taille de la (des)
cellule(s). Ce champ peut prendre les valeurs suivantes : GridBagConstraints.NONE , BOTH ,
HORIZONTAL , VERTICAL
anchor pour indiquer comment le composant se place dans la (les) cellule(s). Ce champ peut prendre les
valeurs suivantes : GridBagConstraints.NONE , CENTER , NORTH, NORTHEAST , EAST ,
SOUTHEAST , SOUTH , SOUTHWEST , WEST et NORTHWEST.
insets pour définir les marges externes du composant. Ce champ est positionné en faisant
new Insets(h,g,b,d) où h définit la marge haute, b la marge basse, g la marge gauche et d la marge droite.
weigthx et weighty permettent d’indiquer quelle part de surface est distribuée ou retirée à ce composant lors
d’un redimensionnement de la fenêtre. Il expriment un pourcentage de répartition de largeur
(respectivement hauteur) pour ce composant.
La classe CardLayout
Cette classe permet d'organiser les éléments de l'interface en pages superposées. Il n'y a pas d'onglets mais il est
possible à l'applet de faire apparaître l'une des pages en premier plan. Si l'on veut que l'utilisateur puisse changer
de page, il faudra prévoir dans chaque page des composants dont l'action associée consiste à changer de page.
Lorsque l'on a créé un objet de classe CardLayout (construction sans paramètre) on va le définir comme objet
de placement du contenant (méthode setLayout de ce dernier). Ensuite de quoi il suffit d'ajouter les pages en
définissant pour chacune l'élément qu'elle contient (cet élément peut être un simple composant ou un contenant
de classe Panel si l'on veut pouvoir mettre plus d'un composant par page). L'addition d'un élément à une page se
fait par la méthode add du contenant auquel a été associé l'objet de classe CardLayout par la méthode :
void add(String,Component) où le premier paramètre est le nom de la page et le second l'élément qu'elle
contient
La mise en premier plan d'une page donnée se fera grâce à la méthode show de l'objet de classe CardLayout :
void show(Container, String) où le premier paramètre est le contenant auquel est associé l'objet de classe
CardLayout et le second paramètre le nom de la page à mettre en premier plan.
2.1.4 Exemple de placement de composants dans une interface graphique

On veut définir une interface ayant l’aspect ci-dessous.
On va pour cela tracer une grille correspondant à la zone réservée à l’applet et déterminer la position et la taille
de chaque composant :
Bouton
Nom
Bouton
Zone de Valider
texte
Bouton
Prénom
Liste Case à
cocher :
Marié
de
prénoms Titre
Placement des composants dans la fenêtre principale (celle de l’applet) :

13
Composant Coordonnées taille marges remplissage positionne marges Redimension
internes ment externes -nement
Bouton Nom 0,0 2,1 2,2 BOTH CENTER 3 , 3 , 0 , 0 0 ,50
Bouton Prénom 0,2 1,1 2,2 BOTH CENTER 0 , 3 , 3 , 0 0,0
Zone de texte 1,1 1,1 2,2 NONE WEST 0,0,0,0 100 , 0
Sous le texte 1,2 1,1 2,2 BOTH CENTER 0 , 3 , 3 , 0 100 , 50
Bouton Valider 2,0 1,3 10 , 3 BOTH CENTER 3 , 0 , 3 , 3 0,0
Si on redimensionne cette fenêtre, la hauteur se répartira entre les lignes 0 et 2 désignées par les deux boutons
Nom et Prénom (50% pour chacun) et la largeur ira à la colonne 2 désignée par le bouton valider (100%)
Placement des composants dans la case sous la zone de texte :

Composant Coordonnées taille marges remplissage positionne marges Redimension
internes ment externes -nement
Liste de prénoms 0,0 1,2 2,2 BOTH WEST 0,0,0,0 100 , 100
Case à cocher 1,0 1,1 2,2 NONE NORTH 0,0,0,0 0,0
Titre 1,1 1,1 2,2 NONE NORTH 0,0,0,0 0,0
Le fichier correspondant est le suivant :
import javax.swing.*;
import java.awt.*;
public class PlacementApplet extends JApplet {

// definition des noms de composants
private JButton afficheNom; // Le bouton "Nom"
private JButton affichePrenom; // Le bouton "Prénom"
private JTextField affichage; // La zone ou s'affiche l'identité
private JButton valider; // Le bouton de validation
private JList prenoms; // La liste proposant des prénoms
private JCheckBox marie; // La case à cocher "Marié"
private JLabel titre; // Le titre de la fiche
public void init() {
// définition des noms d'objets d'interface

afficheNom=new JButton("Nom");
affichePrenom=new JButton("Prenom");
valider=new JButton("Valider");
affichage=new JTextField("abcdefghijklmnopqrstuvwxyz",40);
String[] donnees = {"Arthur","Bertrand","Claude","David","Emile","François"};
prenoms=new JList(donnees);
marie=new JCheckBox("Marié");
titre=new JLabel("FICHE D'IDENTITE");
// définition des objets utilisés pour placer les composants

GridBagLayout placeur=new GridBagLayout(); // objet de placement des composants
GridBagConstraints contraintes=new GridBagConstraints(); // regles de placement
getContentPane().setLayout(placeur); // utiliser cet objet de placement pour la fenêtre
// placement du bouton afficheNom

contraintes.gridx=0; contraintes.gridy=0; // coordonnées 0,0
contraintes.gridwidth=2; contraintes.gridheight=1; // 2 cases en largeur
contraintes.fill=GridBagConstraints.BOTH;
contraintes.anchor=GridBagConstraints.CENTER;
contraintes.weightx=0; contraintes.weighty=50;
contraintes.insets=new Insets(3,3,0,0);
contraintes.ipadx=2; contraintes.ipady=2;
placeur.setConstraints(afficheNom, contraintes);
getContentPane().add(afficheNom);
// placement du bouton affichePrenom

contraintes.gridwidth=1; contraintes.gridheight=1; // occupe 1 case
placeur.setConstraints(affichePrenom, contraintes);

14
getContentPane().add(affichePrenom);
// placement de la zone de texte

contraintes.anchor=GridBagConstraints.WEST;
placeur.setConstraints(affichage, contraintes);
getContentPane().add(affichage);
// placement du bouton valider

contraintes.gridwidth=1; contraintes.gridheight=3; // 3 cases en hauteur
placeur.setConstraints(valider, contraintes);
getContentPane().add(valider);
// Ajout d'un JPanel pour placer les autres composants dans la case
// du milieu en bas et création d'un objet de placement pour ce JPanel
GridBagLayout panelPlaceur=new GridBagLayout(); // objet de placement pour le panel
GridBagConstraints panelContraintes=new GridBagConstraints(); // règles de placement
Panel caseDuBas=new Panel(panelPlaceur); //création du Panel avec son objet de placemt
// placement des 3 composants dans le Panel

// placement de la liste dans un JscrollPane pour avoir des ascenseurs
prenoms.setVisibleRowCount(3); // 3 lignes visibles dans la liste
JScrollPane defile=new JScrollPane(prenoms);
panelContraintes.gridx=0; contraintes.gridy=0; // coordonnées 0,0
panelContraintes.gridwidth=1; contraintes.gridheight=2; // occupe 2 cases
panelContraintes.fill=GridBagConstraints.BOTH;
panelContraintes.anchor=GridBagConstraints.WEST;
panelContraintes.weightx=100; contraintes.weighty=100;
panelContraintes.insets=new Insets(0,0,0,0);
panelContraintes.ipadx=2; contraintes.ipady=2;
panelPlaceur.setConstraints(defile, panelContraintes);
caseDuBas.add(defile);
// placement de la case à cocher
panelContraintes.gridwidth=1; contraintes.gridheight=1; // occupe 1 case
panelContraintes.fill=GridBagConstraints.NONE;
panelContraintes.anchor=GridBagConstraints.NORTH;
panelPlaceur.setConstraints(marie, panelContraintes);
caseDuBas.add(marie);
// placement du titre
panelContraintes.gridwidth=1; contraintes.gridheight=1; // occupe 1 case
panelContraintes.fill=GridBagConstraints.NONE;
panelContraintes.anchor=GridBagConstraints.NORTH;
panelPlaceur.setConstraints(titre, panelContraintes);
caseDuBas.add(titre);
// placement du panel dans l'applet

contraintes.gridx=1; contraintes.gridy=2; // coordonnees 1,2
contraintes.gridwidth=1; contraintes.gridheight=1; // 1 case en hauteur
placeur.setConstraints(caseDuBas, contraintes);
getContentPane().add(caseDuBas);

15
}
2.1.6 Traitement des événements

Chacun des constituants de l’interface est susceptible, selon sa classe, de réagir à certains types d’événements.
On peut associer à chacun un écouteur d'événements qui est un objet contenant une ou plusieurs méthodes de
traitement des événements. Ces méthodes seront alors automatiquement exécutées lorsque l'événement se
produira.
On définit ces objets de traitement par des classes obtenues, selon le cas, par implémentation d'une interface de
contrôle ou par héritage d'un modèle de contrôleur. Ces classes peuvent être des classes internes à celle qui
définit l'interface, elles peuvent être privées.
Une instance d'écouteur (instance d'un objet de la classe définie précédemment) est associé à chaque constituant
de l’interface par sa méthode addxxxListener (se reporter à la description des méthodes des différents
constituants d'interface en 2.1.2, 2.1.3.2 et 2.1.3.4)
2.1.6.1 Les événements élémentaires

Tous les constituants de l’interface sont sensibles à ces événements. Il s'agit des événements du clavier et de la
souris.
Les événements correspondants sont les suivants :
Type événement classe d’événement

d’événement
Clavier touche appuyée, touche lâchée ou touche tapée KeyEvent
Souris clic, entrée ou sortie du curseur de la souris dans le composant, bouton MouseEvent
de la souris appuyé ou lâché.
Souris déplacée éventuellement avec un bouton appuyé
Les écouteurs seront obtenus par héritage de la classe modèle. Les classes modèles et les méthodes associées à
ces événements sont décrits par le tableau ci-dessous :
Type événement classe modèle classe d’événement nom de méthode

d’événement interface modèle associée
Clavier touche appuyée keyPressed
touche lâchée KeyAdapter KeyEvent keyReleased
touche tapée KeyListener keyTyped
Souris clic MouseEvent mouseClicked
le curseur rentre dans le mouseEntered
composant
le curseur sort du composant MouseAdapter mouseExited
un bouton de la souris appuyé MouseListener mousePressed
un bouton de la souris lâché mouseReleased
souris déplacée avec un bouton MouseMotionAdapter MouseMotionEvent mouseDragged
appuyé MouseMotionListener
souris déplacée mouseMoved
ATTENTION : Lorsqu'un événement clavier se produit, il est envoyé au composant actif. Un composant peut être
rendu actif par l'utilisateur (à la souris) ou en utilisant sa méthode requestFocus() voir (2.1.1)
Pour les événements clavier ou souris il est possible de tester le contexte précis de l'événement (touches
modificatrices du clavier et boutons de la souris). Pour cela on utilise la méthode getModifiers() de l ’événement
qui retourne un entier représentant ce contexte. Les tests suivants indiquent comment interprêter cette valeur (le
nom evt désigne l’événement clavier ou souris testé , il est de classe KeyEvent ou MouseEvent) :
if ((evt.getModifiers() & InputEvent.SHIFT_MASK)!=0) // la touche shift est appuyée
if ((evt.getModifiers() & InputEvent.ALT_MASK)!=0) // la touche alt est appuyée
if ((evt.getModifiers() & InputEvent.CTRL_MASK)!=0) // la touche control est appuyée
if ((evt.getModifiers() & InputEvent.BUTTON1_MASK)!=0) // le bouton gauche de la souris est enfoncé
if ((evt.getModifiers() & InputEvent.BUTTON3_MASK)!=0) // le bouton droit de la souris est enfoncé

16
La méthode suivante ne concerne que les événements liés au clavier
char getKeyChar() qui retourne la caractère tapé
Les méthodes suivantes ne concernent que les événements liés à la souris

int getX() qui retourne la coordonnée horizontale du curseur de la souris au moment de l’événement
int getY() qui retourne la coordonnée verticale du curseur de la souris au moment de l’événement
int getClickCount() qui retourne le nombre de clics effectués
La méthode void consume() est utilisée pour les événements clavier et souris. Elle permet de signaler à java que
l’événement a été traité et qu’il n’est donc plus nécessaire de le diffuser.
2.1.6.3 Les événements de composants d'interface

Ce sont ceux qui se produisent lorsque l'on coche une case, on sélectionne un élément dans une liste etc.
Les événements correspondants sont les suivants :
Type événement classe d’événement

d’événement
Action action sur le composant (clic sur un bouton, choix dans un menu ...) ActionEvent
Ajustement déplacement d’un ascenseur AdjustmentEvent
Changement modification de la position d'un composant ChangeEvent
Elément modification de l’état d’un élément (liste, case à cocher ...) ItemEvent
Document modification dans un texte DocumentEvent
Curseur déplacement du curseur d'insertion dans un texte CaretEvent
Sélection sélection d'un élément dans une liste ListSelectionEvent
Chaque composant est susceptible de réagir à certains de ces événements mais pas à tous. Le tableau suivant
donne, pour chaque composant, les événements auxquels il est sensible :
Action Ajustement Changement Elément Document Curseur Sélection

Evénement
Composant
JButton X X X
JCheckBox X X X
JComboBox X
JList X
JSrollBar X
JSlider X
JProgressBar X
JTextField X X(1) X
JTextArea X(1) X
JMenu X X X
JMenuItem X X X
(1) Les composants JTextField et JTextArea ne sont pas directement sensibles à l'événement de document, mais
ils sont associés à un objet de classe Document qui l'est (voir 2.1.2.9)
Remarque : Les croix marquées en gras correspondent aux événements généralement traités pour ce type de
composant. Par exemple l'événement 'changement' pour un JButton est produit quand on enfonce le bouton et
quand on le lâche alors que l'événement 'action' est produit quand on clique le bouton ce qui est généralement
l'utilisation normale d'un tel composant.
Les écouteurs seront obtenus par une classe implémentant l'interface associée. Ces interfaces et les méthodes
associés à ces événements sont décrits par le tableau ci-dessous :

17
Type événement interface associée classe d’événement nom de méthode
d’événement associée
Action activation de bouton, case cochée, ActionListener ActionEvent actionPerformed
choix dans un menu ou choix d'un
fichier, saisie de texte
Ajustement modification de la position de AdjustmentListener AdjustmentEvent adjustmentValueCh
l'ascenseur anged
Changement modification de la position d'un ChangeListener ChangeEvent stateChanged
curseur ou d'une barre de
progression
Elément sélection d'un élément ItemListener ItemEvent itemStateChanged
Document modification, insertion ou DocumentListener DocumentEvent changedUpdate
suppression de texte removeUpdate
insertUpdate
Curseur déplacement du curseur d'insertion CaretListener CaretEvent caretUpdate
Sélection sélection d'un ou plusieurs ListSelectionListener ListSelectionEvent valueChanged
éléments
Remarque : Dans le cas des sélections l'événement est produit lors d'une modification de la sélection. Ceci
signifie que si l'on sélectionne un élément déjà sélectionné il ne se passe rien. De plus, quand on sélectionne un
nouvel élément, l'événement se produit 2 fois (quand on appuie le bouton de la souris et quand on le lâche). On
peut éviter de traiter cet événement intermédiaire en utilisant la méthode getValueIsAdjusting() de l'événement
de classe ListSelectionEvent qui retourne true si l'événement est intermédiaire (on peut alors l'ignorer).
ATTENTION : lorsque l'interface de contrôle possède plusieurs méthodes, toutes doivent être écrites même si
elles sont vides.
2.1.6.4 Associer un écouteur à un événement

Pour chaque élément pour lequel on veut traiter les événements il faudra :
créer une classe obtenue, selon le cas, par implémentation d'une interface ou par héritage d'un modèle
d'écouteur correspondant au type d’événement que l’on désire traiter.
- y écrire les actions associées aux événements dans les méthodes correspondantes. Si l'écouteur a été défini à
partir d'une interface toutes les méthodes doivent être écrites même si elles sont vides. S'il a été défini par
héritage d'une classe modèle, seules les méthodes utiles sont écrites (les autres sont héritées vides).
- associer cette classe au composant par la méthode addxxxListener de celui-ci. On utilisera selon le cas
addActionListener, addMouseListener ... (se reporter aux tableaux précédents pour les noms)
Par exemple pour définir la classe associée aux clics sur le bouton ‘Valider’ de notre interface graphique du 2.1.4
il faudra faire :
private class ActionValider implements ActionListener {
public synchronized void actionPerformed(ActionEvent e) {
// action associée au clic du bouton valider
// le paramètre permet de savoir quel événement s’est produit et dans quelle conditions
}
}
Remarque : Cette classe sera une classe interne à celle qui définit l’applet.
Pour associer ceci au bouton il faudra ajouter, dans le constructeur de l’applet (après la création de l’objet
correspondant à ce bouton), la ligne suivante :
valider.addActionListener(new actionValider());
Pour aller plus loin il faudra se reporter à la documentation de java pour y trouver plus d’informations sur les
classes de composants et d’événements ainsi que toutes les classes qui n’ont pas été évoquées ici.
Pour utiliser la documentation enligne se reporter à l'URL :
java.sun.com/j2se/1.4.2/docs/api

18
2.2 Le graphique
On utilisera, en général, pour faire du graphique, un composant de classe Canvas ou JPanel. Chaque composant
possède son propre système de coordonnées dont le point 0,0 est en haut à gauche et les axes sont orientés vers la
droite (axe des x) et vers le bas (axe des y). La couleur du tracé peut être définie par la méthode setForeground
et on peut connaître sa valeur par getForeground (voir 2.1.1).
Pour pouvoir dessiner il faut disposer d’un objet de classe Graphics. On obtient un tel objet par appel de la
méthode getGraphics du composant (voir 2.1.1).
Chaque fois que le composant devra être dessiné ou redessiné à l’écran java fera appel à sa méthode update.
Cette méthode efface le fond puis le remplit avec sa couleur et enfin invoque la méthode paint du composant. Il
est possible de surcharger, dans une classe dérivée de celle du composant, les méthodes update et/ou paint pour
les doter d’un comportement particulier. Elles sont définies comme suit :
public void update (Graphics g)
public void paint (Graphics g)
Lorsque l’on désire rafraîchir l’affichage d’un composant en dehors des instants où java le fait, on peut appeler la
méthode repaint dont le fonctionnement est le même que celui décrit ci-dessus (appel de update etc.).
L’utilisation directe d’un objet de classe Canvas pose le problème de la mise à jour de l’affichage puisque la
méthode paint d'origine ne fait rien. Il est donc nécessaire de créer sa propre classe dérivée de Canvas pour la
doter d’une méthode paint. La solution la plus générale est de créer une classe possédant une zone de mémoire
dans laquelle seront faits les dessins. La méthode paint de cette classe se contentera alors d’afficher cette zone
de mémoire à l’écran. On peut obtenir une telle zone de mémoire pour tout composant par la méthode
createImage. De plus, afin d’éviter les clignotements, on peut réécrire la méthode update de façon à ce qu’elle
n’efface pas le fond. La classe définie ci-dessous permet ce fonctionnement :
import java.awt.*;
class ZoneGraphique extends JPanel {

// Extension de la classe JPanel de swing :
// Contient un tampon en mémoire dans lequel on peut dessiner.
// Ce tampon est affiché à l'écran chaque fois que l'on appelle la méthode
// repaint() ou chaque fois que java fait un paint() (la fenêtre apparaît, bouge ...).
// Ce tampon est de la classe Graphics de AWT et on y accède par la méthode
// obtenirGraphics() on peut lui appliquer toutes les méthodes de dessin définies
// dans la classe Graphics (voir AWT).
private Image dessin=null; // tampon de dessin

public int taillex=0; // dimensions de la zone de dessin
public int tailley=0; // ces valeurs sont accessibles de l'exterieur
private void creerTampon() { // creation du tampon

taillex=getSize().width; // taille du tampon
tailley=getSize().height;
dessin=createImage(taillex, tailley); // creation du tampon
}
public Graphics obtenirGraphics() {

// retourne le tampon dans lequel on peut dessiner et qui sera affiché
// à l'écran par paint() et repaint()
// voir si la taille de la zone de dessin n'a pas change
// c'est le cas lorsque l'utilisateur redimensionne la fenetre
if ((taillex != getSize().width) || (tailley != getSize().height)) {
creerTampon(); // si oui, il faut recreer le tampon
}
return dessin.getGraphics(); // retourne le tampon de dessin
}
public void update(Graphics g) {

// Surdéfinition de update() pour qu'elle n'efface pas
paint(g);
}
public void paint(Graphics g) {

// Surdéfinition de paint() pour qu'elle affiche le tampon à l'écran
if (dessin != null) g.drawImage(dessin,0,0,this); // affichage du tampon
}

19
}
3 Un petit d’exemple d’applet

Afin d’illustrer tout ceci voici une petite applet qui affiche une image et propose trois boutons. A l'aide de ces
boutons on peut faire la pluie et le beau temps sur cette image.
- Le bouton "soleil" affiche l'image normalement
- Le bouton "pluie" ajoute des gouttes d'eau qui tombent sur l'image
- Le bouton "neige" ajoute des flocons de neige qui tombent sur l'image
La page Web contenant l'applet a l'apparence suivante :
texte contenu dans la

page HTML
zone réservée à l'image
boutons de choix de la
météo
texte contenu dans la

page HTML
Tout d’abord le fichier HTML contenant cette applet (c’est le strict minimum) :
<html>
<head> textes HTML
<title>METEO</title>
</head>
<body>
<h1>Montaury</h1>
<hr>
<APPLET CODE="Meteo.class" CODEBASE="applets" WIDTH="307" HEIGHT="250">
</APPLET>
<hr>
<h1>Sale temps</h1> Applet
</body>
</html>

20
L'applet
L'applet met en place une interface constituée d'une zone graphique pour afficher et animer l'image et de trois
boutons pour choisir la météo. Elle utilise pour cela un GridBagLayout comme suit :
- La première ligne contient la zone graphique qui occupe 3 colonnes
- La seconde ligne contient un bouton par colonne
La zone graphique est constituée d'un objet de classe "Paysage" qui hérite de Canvas et est un processus de java
(il sera décrit plus loin).
Le code de l'applet est le suivant :
import java.awt.*;
import java.net.*;
import java.awt.event.*;
/* Applet qui affiche une photo de paysage et 3 boutons.

Grâce aux boutons on peut avoir la photo seule ou la photo sur laquelle tombent des flocons
de neige ou des gouttes de pluie */
public class Meteo extends JApplet {

private Paysage pays; // zone graphique et processus qui ajoute la météo à la photo
private JButton soleil, neige, pluie; // boutons pour choisir la météo
private ImageIcon fond; //photo du paysage
public void init() {

setBackground(new Color(200,200,200)); // couleur de fond de l'applet (gris clair)
// définition des objets utilisés pour placer les composants

GridBagLayout placeur = new GridBagLayout(); // objet de placement des composants
GridBagConstraints contraintes = new GridBagConstraints(); // règles de placement
getContentPane().setLayout(placeur); // utiliser cet objet de placement pour l'applet
// récupération de l'image du paysage

try {
fond = new ImageIcon(new URL(getCodeBase(),"images/IUT.jpg"));
}
catch(MalformedURLException mfe) {}
// placement de l'image
pays = new Paysage(fond); //le processus qui fait la météo
contraintes.gridwidth=3; contraintes.gridheight=1; // occupe 3 cases de largeur
contraintes.fill=GridBagConstraints.BOTH; // occupe toute la place disponible
contraintes.weightx=100; contraintes.weighty=100; // récupère toute la place
placeur.setConstraints(pays, contraintes);
getContentPane().add(pays); // ajout à l'interface
// placement des trois boutons

soleil = new JButton("Soleil"); // création du bouton
soleil.addActionListener(new ActionSoleil()); // action associée au bouton
contraintes.fill=GridBagConstraints.HORIZONTAL; // occupe toute la largeur disponible
contraintes.weightx=33; contraintes.weighty=0; // récupère 1/3 de la place en largeur
placeur.setConstraints(soleil, contraintes);
getContentPane().add(soleil); // ajout à l'interface
neige = new JButton("Neige"); // création du bouton

neige.addActionListener(new ActionNeige()); // action associée au bouton
placeur.setConstraints(neige, contraintes);
getContentPane().add(neige); // ajout à l'interface
pluie = new JButton("Pluie"); // création du bouton

pluie.addActionListener(new ActionPluie()); // action associée au bouton
placeur.setConstraints(pluie, contraintes);
getContentPane().add(pluie); // ajout à l'interface
}

21
public void start() { //démarrer l'animation
pays.lancerAnimation();
}
public void stop() { //arrêter l'animation

pays.arreterAnimation();
}
/* Les classes d'écouteurs associés aux trois boutons */

private class ActionSoleil implements ActionListener {
pays.enleveObjets(); // on enlève les flocons ou les gouttes de pluie
}
}
private class ActionNeige implements ActionListener {

for(int i=0; i<300; i++) { // on crée 300 flocons
pays.ajouteObjet(new Flocon(pays.largeur(),pays.hauteur()));
}
}
}
private class ActionPluie implements ActionListener {

for(int i=0; i<400; i++) { // on crée 400 gouttes de pluie
pays.ajouteObjet(new Pluie(pays.largeur(),pays.hauteur()));
}
}
}
La zone graphique :
La zone graphique est un objet de classe "Paysage" qui hérite de Canvas de façon à pouvoir être inséré dans
l'interface de l'applet et est un processus java pour faire l'animation des gouttes de pluie ou des flocons de neige.
Elle utilise une collection (Vector) "d'objets volants" qui seront, selon le cas, des gouttes de pluie ou des flocons
de neige. Pour l'affichage elle utilise un objet de classe Image qui est un buffer en mémoire. Dans ce buffer elle
dessinera l'image de fond puis ajoutera les objets volants. Lorsque l'image est prête, elle est affichée dans la zone
graphique du Canvas. Ceci est obtenu en surchargeant la méthode paint de Canvas.
Le code de la classe Paysage est le suivant :
import java.awt.*;
import java.util.*;
/* Classe processus qui ajoute des gouttes de pluie ou des flocons de neige sur une image
*/
public class Paysage extends Canvas implements Runnable {
private Vector table; //collection d'objets volants

private ImageIcon photo; //image de fond
private Image mem; //image mémoire pour ajouter les objets
private Graphics gmem; //contexte graphique de l'image mémoire mem
private int hauteur, largeur; //dimensions du Canvas
private Thread processus; // Thread java utilisé pour lancer ce processus
private int delai; //délai entre deux déplacements d'objets
Paysage(ImageIcon img) {
table = new Vector(0,1); // création de la collection de gouttes ou de flocons
mem = null;
photo = img;
processus = null;
delai = 50;
}
public int largeur() { return largeur; }

public int hauteur() { return hauteur; }
public void lancerAnimation() {

if (processus==null) { // ce test permet de ne le lancer qu'une seule fois

22
processus = new Thread(this); // creation du Thread de java
processus.start(); // lancement de ce processus
}
}
public void arreterAnimation() {

processus.stop(); // arrêt de processus
processus = null; // suppression du thread de java
}
public void run() { // ce que fait ce processus

while (processus!=null) { // tant qu'il n'est pas arrêté
repaint(); //rendre visibles les modifications de limage
try {
if (mem!=null) { // faire bouger tous les objets
for (int i=0; i<table.size(); i++) // balayer la collection
((ObjetVolant)(table.elementAt(i))).bouge(largeur, hauteur);
}
processus.sleep(delai); // delai entre les movements de gouttes ou flocons
} catch (InterruptedException e){}
}
}
public void paint(Graphics g) {

if (mem==null) { //si pas déjà fait : création d'un buffer d'image en mémoire
largeur = getSize().width;
hauteur = getSize().height;
mem = createImage(largeur,hauteur); // création du buffer d'image en mémoire
gmem = mem.getGraphics(); // objet Graphics associé à ce buffer
}
gmem.drawImage(photo.getImage(),0,0,this); //dessiner l'image dans ce buffer

for (int i=0; i<table.size(); i++) // y ajouter les gouttes ou les flocons
((ObjetVolant)(table.elementAt(i))).dessine(gmem);
g.drawImage(mem,0,0,this); //afficher l'image mémoire (buffer) dans le Canvas
}
public void update(Graphics g) {

paint(g); //supprimer l'effacement normalement fait par update
}
public void ajouteObjet(ObjetVolant obj) {

table.addElement(obj); // ajout de l'objet à la collection
}
public void enleveObjets() {

table.removeAllElements(); //on enlève tous les objets de la collection
}
}
Les gouttes de pluie et les flocons de neige :

Pour définir les gouttes et les flocons on va tout d'abord créer une classe d'objets volants c'est-à-dire d'objets
sachant se déplacer selon une vitesse et un angle. Cette classe servira de base à la création, par héritage, des
deux classes pour les gouttes de pluie et les flocons de neige. Ces classes surchargeront la méthode "dessiner" de
façon à tracer des lignes obliques grises pour la pluie et des disques blancs pour la neige.
Le code de la classe mère "ObjetVolant" est le suivant :
import java.awt.*;
import java.util.*;
/* Classe mère des objets volants : flocons ou gouttes de pluie */
public class ObjetVolant {
protected int x,y; //position de l'objet
protected double angle; //direction de déplacement
protected int vitesse; //vitesse de déplacement
private Random tirage; //pour tirer des valeurs au hasard
public ObjetVolant(int larg, int haut) {

x=0; y=0; vitesse=0; angle=0;
tirage=new Random();
x=hasard(larg); //rester dans les limites horizontales
y=hasard(haut); //rester dans les limites verticales
vitesse=hasard(4)+1; // vitesse de déplacement prise au hasard entre 1 et 5

23
}
public int hasard(int n) {

return tirage.nextInt(n); // renvoie un entier entre 0 et n-1
}
public void dessine(Graphics g) { // devra être surchargée pour flocon ou goutte

}
public void bouge(int larg, int haut) {

//nouvelle position
x=(int)(x*1.0+vitesse*Math.cos(angle)); // nouvelle coordonnée en x selon l'angle
y=(int)(y*1.0+vitesse*Math.sin(angle)); // nouvelle coordonnée en y selon l'angle
//en cas de sortie du cadre, on fait réapparaître l'objet ailleurs
if (x>larg) { // sortie à droite
x=0;
y=hasard(haut);
}
if (y>haut) { // sortie en bas
y=0;
x=hasard(larg);
}
if (x<0) { // sortie à gauche
x=larg;
y=hasard(haut);
}
if (y<0) { // sortie en haut
y=haut;
x=hasard(larg);
}
}
Enfin pour les gouttes de pluie et les flocons de neige on utilise les classes suivantes :
import java.awt.*;
public class Pluie extends ObjetVolant {
int longueur; // les gouttes de pluie apparaissent comme des traits de cette longueur
public Pluie(int larg, int haut) { //constructeur

super(larg,haut); // construction de la classe mère
longueur=hasard(6)+6; // longueur au hasard entre 6 et 11
vitesse=longueur/2; // vitesse liée à la taille
angle=Math.PI/2+Math.PI/10; // la pluie tombe inclinée
}
public void dessine(Graphics g) { //méthode de dessin

g.setColor(Color.lightGray); // la pluie est grise
int x1=(int)(x*1.0+longueur*Math.cos(angle));
int y1=(int)(y*1.0+longueur*Math.sin(angle));
g.drawLine(x,y,x1,y1); // tracé d'une ligne inclinée de taille 'longueur'
}
import java.awt.*;
public class Flocon extends ObjetVolant {
private int diametre; // diamètre du flocon
public Flocon(int larg, int haut) { //constructeur

super(larg,haut); // construction de la classe mère
diametre=hasard(4)+1; // diamètre au hasard entre 1 et 5
vitesse=diametre; // la vitesse est liée à la taille
angle=Math.PI/2; // les flocons tombent verticalement
}
public void dessine(Graphics g) { //méthode de dessin

g.setColor(Color.white); // les flocons sont blancs
g.fillOval(x,y,diametre,diametre); // ce sont des cercles de taille 'diamètre'
}

24
SOMMAIRE
1 Ecriture d’une applet_______________________________________________________ 1

1.1 Intégration de l’applet dans une page HTML_____________________________________ 1
1.2 Exécution de l’applet _________________________________________________________ 2
1.3 Communications avec l’utilisateur______________________________________________ 2
1.4 Les autres moyens de communication ___________________________________________ 2
1.4.1 Relations de l’applet avec son environnement ___________________________________________ 2
1.4.2 Images et sons ___________________________________________________________________ 3
1.4.3 Changement de page HTML ________________________________________________________ 3
2 Interfaces graphiques avec SWING ___________________________________________ 4
2.1 Réalisation d’une interface graphique___________________________________________ 4
2.1.1 Les classes Component et JComponent ________________________________________________ 4
2.1.2 Les composants de l’interface _______________________________________________________ 5
2.1.2.1 La classe JButton______________________________________________________________ 5
2.1.2.2 La classe JCheckBox___________________________________________________________ 6
2.1.2.3 La classe JLabel ______________________________________________________________ 6
2.1.2.4 La classe JComboBox __________________________________________________________ 6
2.1.2.5 La classe JList ________________________________________________________________ 6
2.1.2.6 La classe JScrollBar ___________________________________________________________ 7
2.1.2.7 La classe JSlider ______________________________________________________________ 7
2.1.2.8 La classe JProgressBar _________________________________________________________ 8
2.1.2.9 Les classes JTextField et JTextArea_______________________________________________ 8
La classe Document _________________________________________________________________ 8
2.1.2.8 La classe Canvas ______________________________________________________________ 9
2.1.3 Placement des objets ______________________________________________________________ 9
2.1.3.1 Définition de l’interface ________________________________________________________ 9
2.1.3.2 Les contenants _______________________________________________________________ 10
2.1.3.3 Les objets de placement _______________________________________________________ 12
2.1.4 Exemple de placement de composants dans une interface graphique ________________________ 13
2.1.6 Traitement des événements ________________________________________________________ 16
2.1.6.1 Les événements élémentaires ___________________________________________________ 16
2.1.6.3 Les événements de composants d'interface _________________________________________ 17
2.1.6.4 Associer un écouteur à un événement _____________________________________________ 18
2.2 Le graphique ______________________________________________________________ 19
3 Un petit d’exemple d’applet ________________________________________________ 20

25

Applets

Transféré par

Droits d'auteur :

Formats disponibles

Applets

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Applets

Transféré par

Droits d'auteur :

Formats disponibles

ECRITURE D’APPLETS EN

JAVA AVEC SWING

1.1 Intégration de l’applet dans une page HTML

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

méthode appelée init stop start paint destroy

1.3 Communications avec l’utilisateur

1.4 Les autres moyens de communication

1.4.1 Relations de l’applet avec son environnement

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

1.4.2 Images et sons

1.4.3 Changement de page HTML

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

Celles propres à la classe JComponent :

2.1.2 Les composants de l’interface

2.1.2.1 La classe JButton

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

2.1.2.3 La classe JLabel

2.1.2.4 La classe JComboBox

2.1.2.5 La classe JList

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

2.1.2.6 La classe JScrollBar

2.1.2.7 La classe JSlider

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

Le curseur présenté ci contre ici est défini par :

2.1.2.8 La classe JProgressBar

2.1.2.9 Les classes JTextField et JTextArea

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

2.1.2.8 La classe Canvas

2.1.3 Placement des objets

2.1.3.1 Définition de l’interface

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

2.1.3.2 Les contenants

Voici les principales méthodes communes à toutes ces classes :

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

String getTitleAt(int) qui retourne le libellé de l’onglet désigné

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

2.1.3.3 Les objets de placement

Les objets de la classe GridBagConstraints comportent les champs suivants :

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

2.1.4 Exemple de placement de composants dans une interface graphique

Placement des composants dans la fenêtre principale (celle de l’applet) :

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

Placement des composants dans la case sous la zone de texte :

Le fichier correspondant est le suivant :

public class PlacementApplet extends JApplet {

public void init() {

// définition des noms d'objets d'interface

// définition des objets utilisés pour placer les composants

// placement du bouton afficheNom

// placement du bouton affichePrenom

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

// placement de la zone de texte

// placement du bouton valider

// placement des 3 composants dans le Panel

// placement du panel dans l'applet

Ecriture d'applets en Java avec JApplet M. DALMAU, IUT de BAYONNE

2.1.6 Traitement des événements

2.1.6.1 Les événements élémentaires