Page d'accueilFindIt !ContactLes applications et les appletsLes containers et la disposition des composants

La bibliothèque JavaTM 1.0

Table des matièresHierarchie des classes

CJava

 Les composants de l'interface utilisateur

Les composants Java
La classe java.awt.Component
Les composants prédéfinis
Comment ça marche ?

 

Les composants Java

Le package java.awt (Abstract Window Toolkit) est le plus riche des packages Java. Il définit toutes les classes permettant de construire et de gérer l'interface utilisateur. Les classes les plus importantes de ce package sont celles qui permettent de créer les différents composants d'une interface utilisateur. Les composants se répartissent en trois catégories :

  1. Les composants prédéfinis sur lesquels l'utilisateur agit directement pour communiquer avec le programme (dans d'autres environnements comme Windows, on les appelle des contrôles). Voici la liste de ceux fournis avec le package java.awt :

    Bouton

    Les boutons (de classe Button) : un programme déclenche une action quand l'utilisateur clique sur un bouton (on entend par cliquer enfoncer et relâcher le bouton de la souris avec le pointeur toujours positionné sur le bouton).

    Boite à cocher

    Les boites à cocher (de classe Checkbox) : ce sont des composants ayant deux états possibles (coché ou non coché), qui permettent de proposer à l'utilisateur d'activer ou désactiver une option par simple clic.

    Boutons radio

    Les boutons radios (de classe Checkbox associés à un ensemble de classe CheckboxGroup). A un moment donné, un seul bouton radio ne peut être choisi parmi ceux de l'ensemble auquel il appartient. Ceci permet de proposer à l'utilisateur un choix parmi plusieurs options.

    Combo box

    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. Cette liste apparaît quand l'utilisateur clique sur la flèche associée au composant et disparaît une fois que celui-ci clique sur une des chaînes de la liste.

    Liste

    Les listes (de classe List) : ce sont des composants qui permettent par simple clic, de sélectionner ou de déselectionner une ou plusieurs chaînes de caractères affichées dans une liste.Contrairement au composant de classe Choice, la liste reste toujours affichée. Les chaînes sélectionnées sont affichées en inverse vidéo.

    Label

    Les labels (de classe Label) : Ce sont les composants les plus simples ; un label permet d'afficher une chaîne de caractères (titre, message, information décrivant un composant juxtaposé,...).

    TextField TextArea

    Les zones de saisies de texte (composant avec une seule ligne TextField ou avec plusieurs lignes TextArea) : Ces composants permettent à l'utilisateur de saisir une chaîne de caractères.

    Ascenseurs

    Les ascenseurs (de classe Scrollbar) : ces composants sont utilisés en association avec un autre composant (en général un container), quand la zone d'affichage de celui-ci est trop petite pour contenir tout ce qu'il peut afficher. L'ascenseur (horizontal et/ou vertical) permet alors à l'utilisateur de déplacer la zone d'affichage sur d'autres portions du composant (comme on bouge des jumelles pour voir différents détails d'un paysage).

     

  2. 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.
  3. 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 :
    • 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, et 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).
    • 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.

Toutes les classes de composants citées ci-dessus dérivent directement ou indirectement d'une unique classe : la classe Component. Cette classe décrit tous les comportements communs à tous les composants.

Voici la hiérarchie des classes qui dérivent de la classe Component :

!

Quand vous recherchez les méthodes disponibles sur une classe dérivée de Component, n'oubliez pas de consulter toutes les super classes dont elle hérite, pour connaître l'ensemble complet de ses fonctionnalités.


Tous ces composants prennent l'aspect de ceux du système sur lequel la Machine Virtuelle fonctionne.
Et les menus dans tout ça ?! Les menus et sous-menus d'une fenêtre sont des instances des classes dérivant de la classe abstract MenuComponent qui n'a pas de lien d'héritage avec la classe Component, c'est pourquoi ils sont traités dans le paragraphe sur les menus.

 

!

Contrairement à d'autres systèmes (Windows, Mac OS,...), il n'existe pas en Java de concept de fichier ressource utilisé pour décrire et créer l'interface utilisateur, et séparé du programme qui s'en sert. Vous devez créer vous-même tous les composants et les ajouter au container qui les contient. Par contre, leur disposition (position et taille) peut être gérée automatiquement par un layout associé à chaque container.

La classe java.awt.Component

Cette classe abstract est la super classe de toutes les classes de composants citées ci-dessus, et implémente l'interface ImageObserver. Elle comporte un très grand nombre de méthodes, qui sont souvent outrepassées par les classes dérivées de Component.
Si vous devez créer une applet ou un programme avec une interface graphique, vous utiliserez les classes de composants ou vous créerez de nouvelles classes qui en dérivent (de la classe Applet notamment). Comme vous aurez à outrepasser ces méthodes ou vous les invoquerez directement ou indirectement, il vous faut bien maîtriser l'utilité de la plupart d'entre elles.

Méthodes

public Container getParent ()
public ComponentPeer getPeer ()
public Toolkit getToolkit ()

Ces méthodes permettent d'obtenir le composant parent (par exemple le container auquel appartient un bouton), le peer d'un composant et le kit d'outils (Toolkit) gérant la création des composants à l'écran.

public boolean isValid ()
public boolean isVisible ()
public boolean isShowing ()
public boolean isEnabled ()

Ces méthodes permettent de savoir si un composant est valide, s'il est visible, s'il est affiché et s'il est utilisable.
Un composant est invalide, quand son image à l'écran ne correspond pas aux valeurs de ses champs, par exemple quand on change sa taille et que l'image du composant n'a pas encore mis à jour.
Tous les composants sont visibles par défaut sauf les fenêtres dont la classe est Window ou ses dérivées. Attention, pour un composant qui n'est pas une fenêtre, visible n'implique pas que l'objet est à l'écran, cela veut dire qu'il faudra l'afficher quand son container sera créé à l'écran
Un composant est affiché quand il est à écran, c'est-à-dire qu'il est visible ET que son container est à l'écran.
Un composant est utilisable (enabled), quand l'utilisateur peut s'en servir ; un composant qui n'est pas utilisable (disabled) est généralement grisé.

public Point location ()
public Dimension size ()
public Rectangle bounds ()

Ces méthodes renvoient la position, la taille et le rectangle englobant d'un composant. Les coordonnées sont exprimées dans le système de coordonnées du parent du composant, sachant que le point (0,0) est en haut à gauche et que l'axe des y descend vers le bas.

public synchronized void enable ()
public synchronized void disable ()
public void enable (boolean cond)

Vous pouvez rendre utilisable ou inutilisable un composant grâce à ces méthodes. Un composant inutilisable (disabled) est généralement grisé.

public synchronized void show ()
public synchronized void hide ()
public void show (boolean cond)

Ces méthodes permettent d'afficher ou d'effacer un composant. Ces méthodes sont surtout utilisées pour afficher ou effacer une fenêtre à l'écran.

public Color getForeground ()
public synchronized void setForeground (Color c)
public Color getBackground ()
public synchronized void setBackground (Color c)
public Font getFont ()
public synchronized void setFont (Font f)
public synchronized ColorModel getColorModel ()

Utilisez ces méthodes pour obtenir ou modifier la couleur d'un composant, sa couleur de fond et la police de caractères qu'il utilise pour afficher son texte (voir aussi la classe Graphics).

public void move (int x, int y)
public void resize (int width, int height)
public void resize (Dimension d)
public synchronized void reshape (int x, int y, int width, int height)

Ces méthodes sont utilisées pour déplacer et modifier la taille d'un composant. Généralement, on ne les appelle pas directement pour placer un composant dans un container : ces composants sont disposés automatiquement par le layout associé au container. Par contre, vous devez donner une dimension aux fenêtres que vous créez.
Si vous voulez utiliser les nouvelles dimensions d'un composant comme dans l'applet Piano, outrepassez la méthode reshape () car les trois autres méthodes appellent cette méthode.

public Dimension preferredSize ()
public Dimension minimumSize ()

Ces méthodes renvoient la taille préférée et la taille minimum d'un composant, pour que son affichage se fasse correctement. Ces méthodes sont appelées par certaines classes de layout, pour connaître les dimensions correctes d'un composant.

public void layout ()

L'implémentation de cette méthode ne fait rien dans la classe Component. Elle est outrepassée notamment par la classe Container, pour disposer les composants appartenant à un container.

public void validate ()

Si un composant est invalide (son image à l'écran ne correspond pas aux valeurs de ses champs), cette méthode appelle layout (). Elle est outrepassée dans la classe Container pour mettre à jour tous les composants d'un container invalide.

public void invalidate ()

Marque un composant et ses parents comme étant invalide. Ainsi, un appel à validate () pourra mettre à jour ces composants invalides.

public Graphics getGraphics ()

Permet de d'obtenir un contexte graphique pour un composant, pour y effectuer des dessins. Cette méthode renvoie null si le composant n'a pas encore été affiché.

public FontMetrics getFontMetrics (Font font)

Permet de récupérer les renseignements concernant une police de caractère (hauteur, largeur,...).

public void paint (Graphics gc)

Cette méthode est appelée quand le dessin d'un composant doit être mis à jour (à la première visualisation d'un composant, quand il change de taille, quand une portion d'un composant cachée par une fenêtre est réaffichée,...). L'implémentation de la méthode paint () de la classe Component ne fait rien. Quand vous créez de nouvelles classes de composants (dérivées d'une des classes Canvas, Applet, Frame,...), vous devez outrepasser cette méthode pour dessiner le composant avec les méthodes de la classe Graphics, si vous ne voulez pas vous en servir comme container.

!

Les composants Java n'utilisent pas le double-buffering (système utilisant une image cachée, copie de l'image d'un composant à l'écran). C'est à dire que, par défaut, à chaque fois qu'un composant a besoin d'être redessiné (même si ce dessin n'a pas changé), la méthode paint () de sa classe est appelée et toutes les instructions de cette méthode sont exécutées. Ceci implique deux inconvénients majeurs :

  • Si le dessin est inchangé (comme par exemple, quand un composant caché par une fenêtre est réaffichée), toutes les instructions de paint () sont réexécutées et ceci peut prendre un certain temps.
  • L'utilisateur voit le dessin se fabriquer à l'écran, ce qui peut être gênant si notamment, vous voulez faire des animations.

Par contre, l'avantage est que moins de mémoire est utilisée pour l'affichage d'un composant (pas de besoin de mémoriser une image copie du composant à l'écran).
Le chapitre sur les images, décrit comment simuler un effet de double-buffering, en créant une image dans laquelle vous dessinez avant de la copier à l'écran.

public void update (Graphics gc)

Cette méthode est appelée indirectement par les méthodes repaint (). La méthode update () remplit d'abord le composant avec sa couleur de fond avant d'appeler paint (). Si le dessin réalisé par les instructions de la méthode paint () occupe la totalité de la surface du composant, outrepassez la méthode update () en appelant directement paint (), ceci évitera que le fond soit rempli inutilement.

public void paintAll (Graphics gc)

Redessine un composant et pour un container tous les composants lui appartenant.

public void repaint ()
public void repaint (long millisec)
public void repaint (int x, int y,
                      int width, int height)
public void repaint (long millisec, int x, int y,
                      int width, int height)

Redessine un composant. Ces méthodes provoque indirectement un appel à update (), soit le plus rapidement possible, soit après au moins millisec millisecondes. x, y, width et height délimite la zone à redessiner.

public void print (Graphics gc)

Imprime le composant. L'implémentation de print () de la classe Component appelle paint ().

public void printAll (Graphics gc)

Imprime un composant et pour un container tous les composants lui appartenant.

public synchronized boolean inside (int x, int y)

Vérifie si le point de coordonnées (x,y) appartient à la boite englobante du composant.

public Component locate (int x, int y)

L'implémentation de cette méthode renvoie le composant lui-même si le point de coordonnées (x,y) appartient à sa boite englobante. Elle est outrepassée dans la classe Container pour rechercher le composant situé au point de coordonnées (x,y) d'un container.

public Image createImage (int width, int height)
public Image createImage (ImageProducer producer)
public boolean prepareImage (Image image, ImageObserver observer)
public boolean prepareImage (Image image, int width, int height,
                               ImageObserver observer)
public int checkImage (Image image, ImageObserver observer)
public int checkImage (Image image, int width, int height,
                         ImageObserver observer)
public boolean imageUpdate (Image img,  int flags,
                              int x, int y,
                              int width, int height)

Ces méthodes permettent de manipuler les images. Voir le chapitre sur les images pour plus de détails. La méthode imageUpdate () est l'implémentation de la méthode de l'interface ImageObserver.

public void deliverEvent (Event evt)
public boolean postEvent (Event evt)
public boolean handleEvent (Event evt)
public boolean mouseDown (Event evt, int x, int y)
public boolean mouseDrag (Event evt, int x, int y)
public boolean mouseUp (Event evt, int x, int y)
public boolean mouseMove (Event evt, int x, int y)
public boolean mouseEnter (Event evt, int x, int y)
public boolean mouseExit (Event evt, int x, int y)
public boolean keyDown (Event evt, int key)
public boolean keyUp (Event evt, int key)
public boolean action (Event evt, Object what)
public boolean gotFocus (Event evt, Object what)
public boolean lostFocus (Event evt, Object what)

Ces méthodes sont utilisées pour la gestion événementielle des composants (voir le chapitre sur la gestion de l'interface utilisateur).

public void requestFocus ()

Permet à un composant de lancer une requête pour obtenir le focus. Si le focus lui est accordé, la méthode gotFocus () sera appelée.

public void nextFocus ()

Donne le focus au composant suivant parmi ceux de la liste des composants d'un container.

public void addNotify ()

Cette méthode est outrepassée par les classes dérivées de Component pour créer le peer d'un composant, qui est sa représentation à l'écran. Elle est appelée indirectement par les méthodes qui gèrent l'affichage des composants.

public synchronized void removeNotify ()

Cette méthode est appelée pour supprimer le peer d'un composant.

protected String paramString ()
public String toString ()

Ces méthodes sont utilisées pour fabriquer une chaîne de caractères décrivant le composant (toString () outrepasse la méthode de la classe Object et appelle la méthode paramString () qui est outrepassée par les classes dérivées de Component).

public void list ()
public void list (PrintStream out)
public void list (PrintStream out, int indent)

Imprime sur System.out ou sur out, la chaîne de caractères décrivant le composant.

Les composants prédéfinis

La classe java.awt.Button

Cette classe qui dérive de la classe Component, est la classe du package java.awt qui permet de créer et de manipuler des boutons. Une fois créé un objet de classe Button, vous devez l'ajouter à un container avec la méthode add () de la classe Container, pour le visualiser.

Constructeurs
public Button ()
public Button (String label)

Ces constructeurs permettent de créer un bouton avec ou sans label (texte affiché dans le bouton).

Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'un bouton.

public String getLabel ()
public void setLabel (String label)

Ces méthodes permettent d'interroger ou de modifier le label d'un bouton.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant le bouton.

Exemples

Applets PlayApplet, AppletButton, TraitementTexte, MessageBoxApplet, BorderBuilder, ShowMenu et MiseAJourHorloge.

La classe java.awt.Checkbox

Cette classe qui dérive de la classe Component, est la classe du package java.awt qui permet de créer et de manipuler des boites à cocher et les boutons radios. Une fois créé un objet de classe Checkbox, vous devez l'ajouter à un container avec la méthode add () de la classe Container, pour le visualiser. Une boîte à cocher ou un bouton radio ont deux états (coché ou non) représentés par une valeur boolean (true ou false).
Pour qu'un objet de classe Checkbox soit un bouton radio, il doit être associé à une instance de CheckboxGroup.

Constructeurs
public Checkbox ()
public Checkbox (String label)

Ces constructeurs permettent de créer une boite à cocher avec ou sans label (texte affiché à côté de la boite à cocher). Par défaut, la boite à cocher n'est pas cochée.

public Checkbox (String label, CheckboxGroup group,
                  boolean state)

Ce constructeur permet de construire une boite à cocher, ou un bouton radio si group est différent de null. Si state est égal à true la boite à cocher est cochée, ou le bouton radio est le bouton coché parmi tous les boutons radios qui appartiennent au groupe group.

Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'une boite à cocher ou d'un bouton radio.

public String getLabel ()
public void setLabel (String label)

Ces méthodes permettent d'interroger ou de modifier le label d'une boite à cocher ou d'un bouton radio.

public boolean getState ()
public void setState (boolean state)

Ces méthodes permettent d'interroger ou de modifier l'état (coché ou non) d'une boite à cocher ou d'un bouton radio.

public CheckboxGroup getCheckboxGroup ()
public void setCheckboxGroup (CheckboxGroup group)

Ces méthodes permettent d'interroger ou de modifier le groupe auquel appartient un bouton radio.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant le composant.

Exemple

Applet DrawIt.

La classe java.awt.CheckboxGroup

Cette classe est la classe du package java.awt qui permet de gérer un ensemble de boutons radios. Parmi tous les boutons radios (de classe Checkbox) associés à une instance de CheckboxGroup, au plus un seul peut être coché.

Constructeur
  public CheckboxGroup ()
Méthodes
public Checkbox getCurrent ()
public synchronized void setCurrent (Checkbox box)

Ces méthodes permettent d'interroger ou de modifier le bouton radio qui est actuellement coché.

public String toString ()
Exemple

Applet DrawIt.

La classe java.awt.Choice

Cette classe qui dérive de la classe Component, est la classe du package java.awt qui permet de créer des composants proposant un choix parmi une liste déroulante. Une fois créé un objet de classe Choice, vous devez l'ajouter à un container avec la méthode add () de la classe Container, pour le visualiser. A chaque choix de la liste est associé un indice, compris entre 0 et le nombre de choix - 1.

Constructeur
public Choice ()
Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'une instance de la classe Choice.

public int countItems ()

Renvoie le nombre de choix possibles dans le composant.

public String getItem (int index)

Renvoie la chaîne de caractères correspondante au choix d'indice index.

public synchronized void addItem (String item)

Permet d'ajouter en fin de liste un nouveau choix égal à la chaîne de caractères item.

public String getSelectedItem ()
public int getSelectedIndex ()

Ces méthodes renvoient soit la chaîne de caractères soit l'indice du choix courant.

public synchronized void select (int index)
                          throws IllegalArgumentException
public void select (String str)

Ces méthodes permettent de désigner le choix courant du composant, soit en donnant son indice index, soit en donnant sa valeur str.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant le composant.

Exemple

Applet CalculetteSimple.

La classe java.awt.List

Cette classe qui dérive de la classe Component, est la classe du package java.awt qui permet de créer des listes permettant de sélectionner un ou plusieurs choix parmi plusieurs chaînes de caractères. Une fois créé un objet de classe List, vous devez l'ajouter à un container avec la méthode add () de la classe Container, pour le visualiser. A chaque choix de la liste est associé un indice, compris entre 0 et le nombre de choix - 1. Il est possible de définir le nombre de lignes qu'une liste peut afficher en même temps, sans utiliser l'ascenseur associée à la liste, mais ce nombre de lignes et la taille du composant dépendent aussi du layout utilisé.

Constructeur
public List ()

Ce constructeur construit une liste dont le nombre de lignes affichées n'est pas déterminé, et qui n'autorise pas la sélection multiple.

public List (int rows, boolean multipleSelections)

Ce constructeur construit une liste dont le nombre de lignes affichées est égal à rows, et qui autorise la sélection multiple si multipleSelections est égal à true.

Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'une liste.

public synchronized void removeNotify ()

Cette méthode outrepasse la méthode removeNotify () de la classe Component pour supprimer le peer d'une liste.

public int countItems ()

Renvoie le nombre de choix possibles dans la liste.

public String getItem (int index)

Renvoie la chaîne de caractères correspondante au choix d'indice index.

public synchronized void addItem (String item)

Permet d'ajouter en fin de liste un nouveau choix égal à la chaîne de caractères item.

public synchronized void addItem (String item, int index)

Permet d'insérer à l'indice index un nouveau choix égal à la chaîne de caractères item (si index est égal à -1, item est ajouté en fin de liste).

public synchronized void replaceItem (String newValue, int index)

Remplace la chaîne de caractères à l'indice index par newValue.

public synchronized void clear ()

Supprime toutes les chaînes de caractères de la liste.

public synchronized void delItem (int index)
public synchronized void delItems (int start, int end)

Supprime le choix à l'indice index, ou tous les choix compris entre les indices start et end.

public synchronized String getSelectedItem ()
public synchronized int getSelectedIndex ()

Ces méthodes renvoient soit la chaîne de caractères sélectionnée soit son indice (en cas de sélection multiple seule la première est renvoyée).

public synchronized String [ ] getSelectedItems ()
public synchronized int [ ] getSelectedIndexes ()

Ces méthodes renvoient soit un tableau des chaînes de caractères sélectionnées soit un tableau de leur indice.

public synchronized void select (int index)
public synchronized void deselect (int index)

Ces méthodes permettent de sélectionner ou de désélectionner une chaîne de caractères en donnant son indice index.

public synchronized boolean isSelected (int index)

Renvoie true si la chaîne de caractères d'indice index est sélectionnée.

public int getRows ()

Renvoie le nombre de lignes visibles dans la liste.

public boolean allowsMultipleSelections ()

Renvoie true si une liste autorise la sélection multiple.

public void setMultipleSelections (boolean v)

Permet d'autoriser ou non la sélection multiple dans une liste.

public int getVisibleIndex ()

Renvoie l'indice de la chaîne de caractères qui a été rendue visible lors d'un précédent appel à la méthode makeVisible ().

public void makeVisible (int index)

Force la chaîne de caractères d'indice index à être visible à l'écran.

public Dimension preferredSize (int rows)
public Dimension preferredSize ()
public Dimension minimumSize (int rows)
public Dimension minimumSize ()

Méthodes de la classe Component, outrepassées pour renvoyer la taille préférée ou la taille minimum d'une liste.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant la liste.

Voici un programme Java simple utilisant une liste : c'est celui de l'applet donnant la liste des caractères Unicode compris entre '\u0080' et '\u00ff'(à copier dans un fichier dénommé Unicode.java et invoqué à partir d'un fichier HTML)

import java.awt.*;
import java.applet.*;
 
public class Unicode extends Applet
{
  public void init ()
  {
    // Utilisation d'un layout grille 1 x 1 qui permet
    // à la liste d'occuper tout l'espace de l'applet
    setLayout (new GridLayout (1, 1));
    
    // Changement de police de caractères
    setFont (new Font("Courier", Font.PLAIN, 12));
    
    // Création d'une liste affichant les caractères
    // Unicode compris entre '\u0080' et '\u00ff'
    List listeCaracteres = new List ();
    for (short i = 0x0080; i <= 0x00ff; i++)
      listeCaracteres.addItem (  "\\u00" + Integer.toHexString (i)
                              + "   "   + new Character ((char)i));
    // Ajout de la liste au container
    add (listeCaracteres);
  }
}
 
Autre exemple

Applet ListePolices.

La classe java.awt.Label

Cette classe qui dérive de la classe Component, est la classe du package java.awt qui permet de créer et de manipuler des labels. Une fois créé un objet de classe Label, vous devez l'ajouter à un container avec la méthode add () de la classe Container, pour le visualiser.

Champs
public final static int LEFT
public final static int CENTER
public final static int RIGHT

Constantes utilisées pour l'alignement du texte dans le composant.

Constructeurs
public Label ()
public Label (String label)
public Label (String label, int alignment)

Ces constructeurs permettent de créer un label avec ou sans texte, et en précisant éventuellement l'alignement du texte dans le composant (égal à LEFT, CENTER ou RIGHT).

Méthodes
public synchronized void addNotify ()

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'un label.

public int getAlignment ()
public void setAlignment (int alignment) throws IllegalArgumentException

Ces méthodes permettent d'interroger ou de modifier l'alignement du texte dans un label (égal à LEFT, CENTER ou RIGHT).

public String getText ()
public void setText (String label)

Ces méthodes permettent d'interroger ou de modifier le texte d'un label.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant le label.

Exemples

Applets CalculetteSimple, TraitementTexte, MessageBoxApplet, MiseAJourHorloge, ListePolices et Nuancier.

La classe java.awt.TextComponent

Cette classe qui dérive de la classe Component, est la super classe des classes de composants TextField et TextArea qui permettent de créer des zones de saisies de texte. Cette classe regroupe l'ensemble des méthodes communes à ces deux classes. Comme elle n'a pas de constructeur public, vous ne pouvez créer d'instance de cette classe.

Méthodes
public synchronized void removeNotify ()

Cette méthode outrepasse la méthode removeNotify () de la classe Component pour supprimer le peer d'une zone de saisie.

public void setText (String t)
public String getText ()

Ces méthodes permettent d'interroger ou de modifier le texte d'une zone de saisie.

public boolean isEditable ()

Renvoie true si le texte d'une zone de saisie est éditable.

public void setEditable (boolean t)

Permet de spécifier si le texte d'une zone de saisie est éditable ou non.

public String getSelectedText ()
public int getSelectionStart ()
public int getSelectionEnd ()

Ces méthodes permettent d'interroger le texte en cours de sélection dans une zone de saisie ou l'indice du début et de la fin du texte sélectionné.

public void select (int selStart, int selEnd)
public void selectAll ()

Ces méthodes permettent de sélectionner une partie du texte de la zone de saisie (comprise entre les indices selStart et selEnd) ou tout le texte de la zone de saisie.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant la zone de saisie.

La classe java.awt.TextField

Cette classe qui dérive des classes TextComponent et Component, est la classe du package java.awt qui permet de créer et de manipuler des zones de saisies de texte d'une seule ligne. Une fois créé un objet de classe TextField, vous devez l'ajouter à un container avec la méthode add () de la classe Container, pour le visualiser. Il est possible d'utiliser les zones de saisie de cette classe pour la saisie de mots de passe en précisant un caractère qui masque les caractères saisis. Toutes les méthodes permettant de manipuler le texte de la zone de saisie sont dans la classe TextComponent.

Constructeurs
public TextField ()
public TextField (int cols)
public TextField (String text)
public TextField (String text, int cols)

Ces constructeurs permettent de créer une zone de saisie avec ou sans un texte de départ, et en précisant éventuellement le nombre de colonnes que doit occuper la zone de saisie.

Méthodes
public synchronized void addNotify () 

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'une zone de saisie d'une seule ligne.

public boolean echoCharIsSet ()

Renvoie true si un caractère de masque est positionné.

public char getEchoChar ()
public void setEchoCharacter (char c)

Ces méthodes permettent d'interroger ou de modifier le caractère de masque en cours d'utilisation.

public int getColumns ()

Renvoie le nombre de colonnes occupées par la zone de saisie.

public Dimension preferredSize (int cols)
public Dimension preferredSize ()
public Dimension minimumSize (int cols)
public Dimension minimumSize ()

Méthodes de la classe Component, outrepassées pour renvoyer la taille préférée ou la taille minimum d'une zone de saisie.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant la zone de saisie.

L'applet CalculetteSimple qui suit est un exemple simple de l'utilisation des classes TextField, Label et Choice. Elle permet d'afficher le résultat d'une opération simple (+, -, * et /) entre deux opérandes. Cet exemple montre au passage comment convertir une chaîne de caractères en un nombre d'un type primitif grâce à la méthode valueOf () de la classe Float (les classes Integer, Long et Double fournissent aussi des méthodes similaires de conversion).

Applet CalculetteSimple

et le programme Java correspondant (à copier dans un fichier dénommé CalculetteSimple.java et invoqué à partir d'un fichier HTML) :

import java.awt.*;
import java.applet.*;
 
public class CalculetteSimple extends Applet
{
  TextField operande1      = new TextField ("2000");
  TextField operande2      = new TextField ("1000");
  Choice    choixOperateur = new Choice    ();
  Label     labelResultat  = new Label     ("3000                   ");
 
  public void init ()
  {
    // Ajout des opérateurs à la liste
    choixOperateur.addItem (" + ");
    choixOperateur.addItem (" - ");
    choixOperateur.addItem (" * ");
    choixOperateur.addItem (" / ");
 
    // Ajout des composants à l'applet
    add (operande1);
    add (choixOperateur);
    add (operande2);
    add (labelResultat);
  }
  
  // Méthode appelée par la machine virtuelle quand on effectue
  // une action sur un des composants
  public boolean action (Event event, Object eventArg)
  {
    try
    {
      // Récupération des valeurs saisies dans les deux champs de saisies
      // La méthode static valueOf () de la classe Float est utilisée pour
      // convertir le texte saisi en un nombre. Cette méthode déclenche une
      // exception de classe NumberFormatException si la chaîne de caractères
      // à convertir n'est pas un nombre
      float valeur1  = Float.valueOf (operande1.getText ()).floatValue ();
      float valeur2  = Float.valueOf (operande2.getText ()).floatValue ();
 
      float resultat = 0;
      // Calcul suivant l'opérateur choisi
      switch (choixOperateur.getSelectedItem ().charAt (1))
      {
        case '+' : resultat = valeur1 + valeur2;
                   break;
        case '-' : resultat = valeur1 - valeur2;
                   break;
        case '*' : resultat = valeur1 * valeur2;
                   break;
        case '/' : resultat = valeur1 / valeur2;
                   break;
      }
 
      labelResultat.setText (" = " + resultat);
    }
    catch (NumberFormatException e)
    {
      // Exception si un des deux opérandes n'est pas un nombre
      labelResultat.setText (" (Calcul impossible)");
    }
    return true;
  }
}
 
Autre exemple

Applet ListePolices.

La classe java.awt.TextArea

Cette classe qui dérive des classes TextComponent et Component, est la classe du package java.awt qui permet de créer et de manipuler des zones de saisies de texte de plusieurs lignes. Une fois créé un objet de classe TextArea, vous devez l'ajouter à un container avec la méthode add () de la classe Container, pour le visualiser. Il est possible d'utiliser les zones de saisie de cette classe pour la saisie de mots de passe en précisant un caractère qui masque les caractères saisis. Toutes les méthodes permettant de manipuler le texte de la zone de saisie sont dans la classe TextComponent. Un exemple plus complet utilisant la classe TextArea est donné au chapitre suivant.

Constructeurs
public TextArea ()
public TextArea (int rows, int cols)
public TextArea (String text)
public TextArea (String text, int rows, int cols)

Ces constructeurs permettent de créer une zone de saisie avec ou sans un texte de départ, et en précisant éventuellement le nombre de colonnes et de lignes que doit occuper la zone de saisie.

Méthodes
public synchronized void addNotify () 

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'une zone de saisie de plusieurs lignes.

public void insertText (String str, int pos)

Permet d'insérer la chaîne de caractères str à la position pos dans le texte de la zone de saisie.

public void appendText (String str)

Permet d'ajouter la chaîne de caractères str à la fin du texte de la zone de saisie.

public void replaceText (String str, int start, int end)

Permet de remplacer par la chaîne de caractères str la partie du texte de la zone de saisie comprise entre les indices start et end.

public int getRows ()
public int getColumns ()

Ces méthodes permettent d'interroger le nombre de colonnes ou le nombre de lignes occupées par la zone de saisie.

public Dimension preferredSize (int cols)
public Dimension preferredSize ()
public Dimension minimumSize (int cols)
public Dimension minimumSize ()

Méthodes de la classe Component, outrepassées pour renvoyer la taille préférée ou la taille minimum d'une zone de saisie.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant la zone de saisie.

Exemple

Applet TraitementTexte.

La classe java.awt.Scrollbar

Cette classe qui dérive de la classe Component, est la classe du package java.awt qui permet de créer et de manipuler des ascenseurs. Une fois créé un objet de classe Scrollbar, vous devez l'ajouter à un container avec la méthode add () de la classe Container, pour le visualiser.

Champs
public final static int HORIZONTAL
public final static int VERTICAL

Constantes utilisées pour préciser l'orientation d'un ascenseur.

Constructeurs
public Scrollbar ()
public Scrollbar (int orientation)
public Scrollbar (int orientation, int value, int visible,
                    int minimum, int maximum )

Ces constructeurs permettent de créer un ascenseur en précisant éventuellement son orientation égale à HORIZONTAL ou VERTICAL (valeur par défaut).
minimum et maximum sont des entiers représentant les valeurs logiques minimale et maximale que peut prendre l'ascenseur (par exemple, 0 et 100 ou -500 et 500). On entend par logique que ces valeurs ne sont pas des valeurs en pixels ou représentant une grandeur physique de l'ordinateur, ce sont des valeurs arbitraires qui n'ont un sens que dans la logique de votre programme (nombre de lignes, valeurs sur un axe de coordonnées,...).
value représente la position logique initiale de l'ascenseur (comprise entre minimum et maximum).
visible représente la taille logique de la portion visible ; par exemple, si un ascenseur verticale est associé à un dessin dont vous ne pouvez afficher que le tiers en hauteur, visible sera égal à (maximum - minimum) / 3.

Méthodes
public synchronized void addNotify () 

Cette méthode outrepasse la méthode addNotify () de la classe Component pour créer le peer d'un ascenseur.

public int getOrientation ()

Renvoie l'orientation de l'ascenseur ( HORIZONTAL ou VERTICAL).

public int getValue ()
public void setValue (int value)

Ces méthodes permettent d'interroger ou de modifier la position courante d'un ascenseur. Si value est plus petite que le minimum de l'ascenseur ou plus grande que le maximum de l'ascenseur, ces valeurs prennent respectivement value pour nouvelle valeur (ceci permet de rajouter facilement des "pages").

public int getMinimum ()
public int getMaximum ()
public int getVisible ()

Ces méthodes permettent d'interroger le minimum, le maximum et la taille logique de la portion visible d'un ascenseur.

public int getLineIncrement ()
public void setLineIncrement (int increment)

Ces méthodes permettent d'interroger ou de modifier la valeur increment à ajouter ou à retrancher à la valeur de la position courante, quand l'utilisateur clique sur les flèches de l'ascenseur.

public int getPageIncrement ()
public void setPageIncrement (int increment)

Ces méthodes permettent d'interroger ou de modifier la valeur increment à ajouter ou à retrancher à la valeur de la position courante, quand l'utilisateur clique dans l'ascenseur.

public void setValues (int value, int visible,
                        int minimum, int maximum)

Modifie la valeur courante, la taille logique de la portion visible, le minimum et le maximum d'un ascenseur.

protected String paramString ()

Méthode de la classe Component, outrepassée pour renvoyer une chaîne de caractères décrivant l'ascenseur.

Comment ça marche ?

Afin de comprendre l'enchaînement des différentes méthodes appelées par le navigateur et une applet, l'applet suivante vous montre le comportement d'une applet simple utilisant un bouton, dont voici le programme (simplifié) :

import java.applet.Applet;
import java.awt.*;
 
public class AppletButton extends Applet   
{
  public void init ()
  {
    Button bouton = new Button ("OK");
    add (bouton);
  }
}

AppletTracer

Sous le bouton, une liste affichant l'ensemble des appels aux méthodes a été ajoutée.

Le peer d'un composant

Si vous pouvez visualiser cette page sous différents systèmes, vous verrez que les composants du package java.awt prennent à chaque fois l'aspect de ceux du système sur lequel le navigateur fonctionne. En regardant le programme Java des classes Component ou de ses dérivées, vous découvrirez que toutes ces classes ne comportent aucune instruction spécifique à chacun des systèmes : par exemple, la classe Button décrite dans le fichier Button.java, est la même pour toutes les Machines Virtuelles Java que vous soyez sous Windows, Mac OS, UNIX,... Comment ceci est-il possible alors qu'un bouton n'a pas le même aspect et est géré différemment sous chacun de ces systèmes ?
En fait, chaque composant du package java.awt a son pair (peer en anglais) auquel il est associé. La classe de ce deuxième objet implémente l'interface Peer associée à la classe du composant (par exemple l'interface ButtonPeer pour un composant de classe Button). Cet objet est mémorisé dans le champ private peer de la classe Component. L'ensemble des interfaces Peer sont déclarées dans le package java.awt.peer.
Le champ peer d'interface ComponentPeer permet de mémoriser un objet dont la classe implémente cette interface ou une de ses dérivées comme par exemple ButtonPeer. Pour créer un objet d'interface ButtonPeer, il faut qu'il existe quelque part une classe implémentant cette interface. Si vous effectuez une recherche dans toutes les classes du package java.awt, vous verrez que Java ne fournit aucune classe implémentant ButtonPeer !?! Et c'est là qu'est l'astuce : chaque Machine Virtuelle fournit des classes dont l'utilisateur n'a pas connaissance et qui implémentent chacune des interfaces Peer. Ces classes déclarent des méthodes native, dont l'implémentation fait appel aux fonctions du système sur lequel la Machine Virtuelle fonctionne (comme par exemple la fonction CreateWindow () utilisée pour créer un composant sous Windows).
Reste une chose : Comment sont liées les classes de composant du package java.awt et les classes de la machine virtuelle implémentant les interfaces Peer ? Par exemple, comment la classe Button fait pour retrouver la classe qui implémente l'interface ButtonPeer, pour pouvoir créer un objet de cette classe ? Il existe une classe Toolkit qui est abstract. En observant cette classe vous verrez qu'il existe toutes les méthodes qui permettent de créer un objet d'interface Peer, et notamment la méthode createButton () qui renvoie un objet d'interface ButtonPeer. Toutes ces méthodes de création sont abstract. La Machine Virtuelle définit une classe dérivant de Toolkit qui implémente toutes ces méthodes abstract. Par exemple, la méthode createButton () va être implémentée de manière à créer une instance de la classe implémentant ButtonPeer.
Le nom de la classe dérivée de Toolkit est mémorisée dans la propriété "awt.toolkit". Grâce à cette propriété, la méthode static getDefaultToolkit () de la classe Toolkit peut, en appelant System.getProperty ("awt.toolkit"), retrouver le nom de cette classe et l'instancier avec Class.forName (nomClasseDeriveeDeToolkit).newInstance (). Ainsi, après avoir obtenu une instance de Toolkit, un bouton crée son pair en appelant createButton (), et le tour est joué !
L'appel aux fonctions de la classe Toolkit, s'effectue dans la méthode addNotify () d'un composant et non dans le constructeur d'un composant. Cette méthode est invoquée soit quand on ajoute un composant à un container avec la méthode add (), soit pour les fenêtres dont la classe dérive de Window quand on appelle la méthode show (). La méthode show () appelle addNotify () pour la fenêtre et pour tous les composants qui lui ont été ajoutés.
En conclusion, les classes de composants du package java.awt sont en fait des représentations logiques des composants et leur objet peer est une représentation à l'écran du composant.

Pour mieux visualiser le raisonnement précédent, la figure suivante montre l'enchaînement des méthodes appelées pour créer un bouton :

Etapes de la création d'un bouton
figure 14. Etapes de la création d'un bouton

!

Si vous ne maîtrisez pas encore la notion d'interface ou le fonctionnement des composants d'une interface utilisateur, vous risquez sûrement de trouver fumeuse l'explication précédente. Après avoir écrit quelques programmes Java, votre curiosité vous amènera peut-être à y revenir.
De toute façon, ce raisonnement a été construit en consultant le code source de Java alors n'hésitez pas à faire de même pour plus de renseignements.

!

Ce système comporte deux inconvénients importants :

  • Vous ne pouvez pas modifier l'aspect d'un composant prédéfini car c'est le peer de ces composants qui gère leur dessin.
    Donc, si par exemple, vous voulez créer un bouton affichant un dessin à la place d'un texte, ne créez pas une classe dérivée de Button en outrepassant la méthode paint (), mais plutôt une classe dérivée de Canvas. Ceci implique que dans cette classe, vous devrez non seulement redessiner entièrement le bouton en outrepassant la méthode paint (), mais en plus reprogrammer son comportement (enfoncement, relâchement, ...).
  • La taille d'un composant prédéfini ne peut être connue ou modifiée tant que sa méthode addNotify () n'a pas encore été appelée. En effet, la taille d'un composant est établie qu'une fois que son peer a été créé. Ce n'est qu'à partir de ce moment que vous pouvez interroger sa taille préférée ou modifier sa taille.

La classe java.awt.Toolkit

Cette classe abstract déclare un ensemble de méthodes abstract appelées pour créer le peer des composants, des menus du package java.awt, gérer les images et obtenir des informations sur l'interface graphique. Pour obtenir une instance de cette classe, vous pouvez appelez la méthode getToolkit () de la classe Component ou la méthode static getDefaultToolkit () de cette classe.

Méthodes
protected abstract ButtonPeer createButton (Button target)
protected abstract ChoicePeer createChoice (Choice target)
protected abstract ListPeer createList (List target)
protected abstract CheckboxPeer createCheckbox (Checkbox target)
protected abstract LabelPeer createLabel (Label target)
protected abstract TextAreaPeer createTextArea (TextArea target)
protected abstract TextFieldPeer createTextField (TextField target)
protected abstract ScrollbarPeer createScrollbar (Scrollbar target)
protected abstract CanvasPeer createCanvas (Canvas target)
protected abstract PanelPeer createPanel (Panel target)
protected abstract FramePeer createFrame (Frame target)
protected abstract WindowPeer createWindow (Window target)
protected abstract DialogPeer createDialog (Dialog target)
protected abstract FileDialogPeer createFileDialog (FileDialog target)
protected abstract MenuBarPeer createMenuBar (MenuBar target)
protected abstract MenuItemPeer createMenuItem (MenuItem target)
protected abstract MenuPeer createMenu (Menu target)
protected abstract CheckboxMenuItemPeer createCheckboxMenuItem
                                             (CheckboxMenuItem target)

Ces méthodes sont appelées dans les méthodes addNotify () des classes de composants passés en paramètre, pour créer le peer de ce composant. Vous n'avez pas à appeler ces méthodes.

public abstract Dimension getScreenSize ()

Renvoie la taille de l'écran.

public abstract int getScreenResolution ()

Renvoie la résolution de l'écran en points par pouce (dpi).

public abstract ColorModel getColorModel ()

Renvoie le modèle de couleur utilisé.

public abstract String [ ] getFontList ()

Renvoie la liste des polices de caractères disponibles.

public abstract FontMetrics getFontMetrics (Font font)

Renvoie la taille de la police de caractères font.

public abstract void sync  ()

Synchronise l'affichage graphique ; cette méthode peut être utile pour réaliser des animations.

public abstract Image getImage (String filename)
public abstract Image getImage (URL url)

Ces méthodes permettent d'obtenir l'image du fichier filename ou à l'URL url. L'image n'est effectivement chargée qu'à sa première utilisation (voir le chargement des images).

public abstract boolean prepareImage (Image image, int width, int height,
                              ImageObserver observer)
public abstract int checkImage (Image image, int width, int height,
                          ImageObserver observer)

Ces méthodes permettent de gérer le chargement d'une image.

public abstract Image createImage (ImageProducer producer)

Permet de créer une image.

public synchronized static Toolkit getDefaultToolkit ()

Renvoie le toolkit par défaut.

Exemples

Applets ListePolices et BoutonsNavigation.


Page d'accueilFindIt !ContactLes applications et les appletsLes containers et la disposition des composantsDébut de la page
© Copyrights 1997-2015 Emmanuel PUYBARET / eTeks
- Tous droits réservés -
Table des matièresHiérarchie des classes