CHAPITRE 6

JAVA ABSTRACT WINDOW

TOOLKIT
Dr. A. Nejeoui

! POO JAVA: GI2

 INTRODUCTION
L’API Java offre un ensemble de packages qui permettent aux
programmeurs de concevoir des applications basés sur des interfaces
graphiques, la collecte des informations se traduit par des interactions
entre l’utilisateur et les composants de l’interface graphique (click de
souris, frappes de clavier et autres ..).
Les objectifs de ce chapitre :
- Décrire le package java.awt et ces composants.
- Définir les termes : conteneur, composant, gestionnaire de
positionnement, et voir comment ces composants collaborent pour
construire une interface graphique.
- Utiliser les gestionnaires de positionnement : FlowLayout, BorderLayout,
GridLayout, CardLayout, GridBagLayout
- Utiliser les conteneurs : Window, Frame, Panel …
- Construire des interfaces graphique complexe par imbrication de
conteneurs.

" POO JAVA: GI2

 LES COMPOSANTS AWT
Java.awt est constitué de plusieurs classes. Pour bien comprendre les
fonctionnalités offertes par ce package on va présenter les classes les
plus utilisées dans ce package et expliquer la relation entre ses différents
composants.

# POO JAVA: GI2

 LA CLASSE COMPONENT
La classe component est une classe abstraite qui représente la classe des
objets qui possèdent une représentation graphique qu’on peut afficher à
l’écran et qui interagissent avec l’utilisateur.
Toute personne utilisant un PC est familier avec les composants : fenêtres,
boutons, cases à couché …
void SetBackground(Color)
void SetSize(int, int)
int getWidth()
int getHeight()
setLocation(int x, int y) // positionner le coins supérieur gauche du
//composant.
Point getLocationOnScreen()

$ POO JAVA: GI2

 LABEL
Lorsque vous réalisez une application graphique, il est important d’y ajouter
suffisamment de libellés afin de faciliter l’ergonomie de cette dernière.
Vous devrez pour cela utiliser la classe Label qui est l’un des
composants awt les plus simples. Il permet d’afficher du texte dans
n’importe quelle position.
Voici un descriptif des méthodes les plus employées :
Label() Crée un libellé vide
Label(String) Crée un libellé avec du texte
Label(String, int) Crée un libellé avec du texte aligné horizontalement
setText(String) Permet de spécifier le texte pour le label.
setBackground(Color) pour définir la couleur de l’arrière plan

% POO JAVA: GI2

 LABEL

& POO JAVA: GI2

 BUTTON
Button est un bouton poussoir classique très simple. Nous pouvons lui
ajouter un texte comme label ou encore appliquer des couleurs arrière et
d’avant plan. De plus on peut ajouter des listeners (ActionListener…)
pour capturer les évènements. Nous reviendrons en détail sur cette partie
dans le chapitre 8 : La gestion des évènements
Voici un descriptif des méthodes les plus employées :
Button()
Button(String)
getLabel()
setLabel(String)
void addActionListener(ActionListener) Ajouter le bouton à un
ActionListener.

' POO JAVA: GI2

 BUTTON

( POO JAVA: GI2

 CHECKBOX ET CHECKBOXGROUP
Une CheckBox est une case à cocher, on peut ajouter un libellé à se
composant directement lors de sa création afin de rendre plus explicite
son utilisation. Il faut pour cela utiliser le constructeur suivant :
CheckBox("un label").
Les CheckBox sont utilisés lors de choix multiples que l’utilisateur doit
réaliser par le biais de l’interface graphique.
Le CheckboxGroup sert à regrouper un ou plusieurs case à coucher de telle
manière à ce que une seule case soit couchée, voir l’exemple suivant :
Voici un descriptif de quelque méthodes les plus employées :
Checkbox()
Checkbox(String label)

) POO JAVA: GI2

 CHECKBOX ET CHECKBOXGROUP

!* POO JAVA: GI2

 CHOICE

Les composants Checkbox et CheckboxGroup provoquent un problème

lorsqu’on a à gérer un grand nombre de choix, ces composants
consomment une grande partie de l’espace réservé à l’interface
graphique. Le composant Choice a été créer pour pallier à ce problème il
permet d’utiliser efficacement l’espace graphique.
Choice();
addItem(String choix)

!!POO JAVA: GI2

 CHOICE

!" POO JAVA: GI2

 LIST
Entre CheckboxGroup et Choice on trouve un autre composant : List. Avec
List le programmeur peut spécifier le nombre de choix visible, les autres
choix sont toujours disponible moyennant un menue déroulant. Par
contre à Choice, Liste permet de faire multiple choix.

List() // tous les éléments sont visibles

List(int nbr) // seules nbr éléments sont visibles
List(int nbr, boolean multipleMode) // seules nbr éléments sont visibles
avec possibilité de choix multiple si multipleMode=true.

!# POO JAVA: GI2

 LIST

!$ POO JAVA: GI2

 TEXTCOMPONENT
Deux composants de java.awt sont disponibles pour saisir du texte à partir du
clavier : TextField pour une seule ligne de texte et TextArea pour plusieurs
lignes de texte.
Voici un descriptif de quelque méthodes les plus employées :
tf1 = new TextField(); // Zone de texte vide
tf2 = new TextField("", 20); // Zone de texte vide avec 20 colonnes
tf3 = new TextField("Hello!"); // Zone de texte avec un texte par défaut
tf4 = new TextField("Hello", 30); // Zone de texte avec un texte par défaut sur 30
colonnes.
TextArea()
TextArea(int rows, int columns)
TextArea(String text)
TextArea(String text, int rows, int columns)
TextArea(String text, int rows, int columns, int scrollbars)

scrollbars== SCROLLBARS_BOTH,
SCROLLBARS_VERTICAL_ONLY,
SCROLLBARS_HORIZONTAL_ONLY,
SCROLLBARS_NONE.

!% POO JAVA: GI2

 TEXTFIELD ET TEXTAREA

!& POO JAVA: GI2

 SCROOLLBAR
Java offre deux composants dont leurs seul but est de générer des
événements : Button et ScrollBar. (tous les autres composants peuvent
générer des événements mais c’est pas la seule fonctionnalité qu’ils
remplissent) .
Tous le monde est familier avec les barres de défilement (ScrollBars), on les
utilise avec les éditeurs de texte dans les pages web…etc. Comme on l’a
déjà cité les ScrollBar génèrent seulement des événement lorsqu’un
utilisateur agit sur eux. Le développeur est responsable de gérer
correctement ces événements pour réaliser la fonction désirée.
Notez bien que plusieurs composants awt dispose de leur inhérents
ScrollBars ce qui facilite énormément la tâche (TextArea, ScrollPane …)

!' POO JAVA: GI2

 LES CONTENEURS
L’interface graphique utilisateur est représenté par une hiérarchie de composants
graphiques que l’on peut schématiser sous forme d’arbre. Dans ce cas les
feuilles représentent des composants. Les noeuds, eux, qui sont constitués de
composants sont appelés conteneurs. En AWT, tous les conteneurs dérivaient
de java.awt.Container.
Un objet de type Container est un conteneur awt qui peut contenir d’autres
composants awt. Les composant ajoutés à un conteneurs sont rangés dans une
liste , si aucun index n’a était spécifié lors de l’ajout, le composant est rangé
dans le dernier élément de la liste.
La classe Container contient en particulier différentes formes de méthodes add et
remove permettant respectivement l'ajout et la suppression d'un composant
dans le conteneur courant dont on peut citer : add(Component comp)
add(Component comp, int index)
getComponent(int n)
setLayout(LayoutManager mgr)
setVisible(boolean b)
!( POO JAVA: GI2
 LES CONTENEURS

!) POO JAVA: GI2

 PANEL

Il s'agit du type de conteneur le plus simple. Le gestionnaire de placement

par défaut en est FlowLayout. Une application peut y attacher tout type
de composants.
Un panaeau (Panel) est tout simplement un espace auquel vous pouvez
attachez d’autres composants y compris d’autres paneau (voir l’exemple
qui suit). Panel accepte deux constructeurs :
Panel()
Panel(LayoutManager layout)

"* POO JAVA: GI2

 PANEL

"! POO JAVA: GI2

 WINDOW
Il s'agit d'une fenêtre sans bordures ni barre de menu dont le gestionnaire
de positionnement par défaut est de type BorderLayout. Lors de sa
construction elle doit appartenir à une instance de Frame (ou une
instance de Dialog ou une autre instance d’un Window).
Les instances de cette classe sont typiquement utilisées pour acquérir des
données de l'utilisateur. (Rarement instanciée directement, on utilise ses
sous-classes Dialog et Frame).
Quelques constructeurs :
Window(Frame owner)
Window(Window owner)

"" POO JAVA: GI2

 WINDOW

"# POO JAVA: GI2

 FRAME
Il s'agit d'une fenêtre avec titre, bordure, boutons de minimisation,
maximisation et fermeture (gestionnaire par défaut BorderLayout). A sa
création, une instance est invisible jusqu'à ce que lui appliquée la
méthode setVisible(true).
Frame vous permet de changer le curseur de la souris, définir une icône
image, et avoir des menus.
Parmi les méthodes de la classe, citons
void setVisible(boolean b);
void setTitle (String titre);
MenuBar getMenuBar()
void setCursor(Cursor c);

"$ POO JAVA: GI2

 FRAME

"% POO JAVA: GI2

 DIALOG (BOÎTE DE DIALOGUE)
C’est une fenêtre de dialogue avec titre et bordures. Une boite Dialogue est
toujours attaché à une autre fenêtre quand il est construite. Lorsque le
propriétaire d'une boite de Dialogue est minimisé, la Une boite sera
automatiquement cacher à l'utilisateur. Lorsque le propriétaire est affiché,
la boîte de Dialogue est affichée.
Quelques méthodes :
Dialog(Dialog owner)
Dialog(Dialog owner, String title)
Dialog(Frame owner)
Dialog(Window owner)
setTitle(String title)
setVisible(boolean b)

"& POO JAVA: GI2

 DIALOG (BOÎTE DE DIALOGUE)

"' POO JAVA: GI2

 FILEDIALOG

fournit une boîte de dialogue préfabriquée qui interagit avec le système de

fichiers. Cette fenêtre implémente la boîte de dialogue Open / Save
native du système de fenêtrage .
Quelques méthodes :
FileDialog(Frame parent, String title,int mode)
// mode =FileDialog.LOAD ou FileDialog.SAVE
void setFile(String file)
void setDirectory(String dir)
String getFile()

"( POO JAVA: GI2

 FILEDIALOG

") POO JAVA: GI2

 SCROLLPANE
Ce composant a été introduit dans la version jdk 1.1, avant si vous avez
besoins par exemple de créer un panneau de 200x200 mais vous voulez
y ranger un contenu qui dépasse cette taille, le seule moyen c’est de
définir un Panel avec BorderLayout comme gestionnaire de
positionnement et par la suite ajouter deux ScrollBar pour gérer le
défilement (un en bas et l’autre à droite et évidement gérer les
événements associés).
Avec la version 1.1 est supérieur vous n’avez qu’ à créer un ScrollPane en
indiquant ce que vous voulez défiler et c’est tout.
Quelques méthodes :
ScrollPane() // par défaut SCROLLBARS_AS_NEEDED
ScrollPane(int scrollbarDisplayPolicy) //
SCROLLBARS_ALWAYS
SCROLLBARS_AS_NEEDED
SCROLLBARS_NEVER

#* POO JAVA: GI2

 SCROLLPANE

#! POO JAVA: GI2

 LES GESTIONNAIRE DE
POSITIONNEMENT
Le positionnement des composants dans les conteneurs est l'affaire des
gestionnaires de positionnement, ou Layout Managers, qui se chargent :
- du positionnement initial des composants, lors des appels de la méthode add,
- le cas échéant, de donner une taille et une forme a chaque composant, en
fonction de sa « taille préférée », de son contenu et de sa disposition
relativement aux autres composants dans le même conteneur,
- du repositionnement des composants lorsque la taille ou la forme du conteneur
change.
Chaque conteneur (Window, Panel, Applet ..) posséde son propre LayoutManager.
Par conséquent, sur un même écran, on peut construire plusieurs conteneurs
avec pour chacun une positionnement spécifique.
Il y a 5 gestionnaires FlowLayout , GridLayout, BorderLayout, CardLayout,
GridbagLayout.

#" POO JAVA: GI2

 FLOWLAYOUT
C'est le plus simple des 5 gestionnaires : il ajoute les composants en les
alignant sur le panneau courant, ligne par ligne et de gauche à droite.
Par défaut les composants sont centrés horizontalement et écartés entre
eux de 5 pixels, mais on peut changer cela au moment de l'instanciation
par exemple :
Pour aligner à gauche ou à droite, ajouter un argument.
setLayout( new FlowLayout( FlowLayout.LEFT) );
Pour imposer un espacement des composants horizontalement, puis
verticalement :
setLayout( new FlowLayout( FlowLayout.LEFT, 30 , 10) );
Sur un objet Panel (panneau), la positionnement par défaut est FlowLayout
il est donc inutile d'indiquer un paramètre de positionnement si vous
voulez utiliser FlowLayout.

## POO JAVA: GI2

 FLOWLAYOUT

#$ POO JAVA: GI2

 FLOWLAYOUT

#% POO JAVA: GI2

 BORDERLAYOUT (BORDURE)
Ce gestionnaire permet de placer les objets dans un conteneur suivant 5
positions indiquées par la valeur d'un paramètre de positionnement de
type chaîne de caractères : North, South, East, West, Center.
C'est le gestionnaire par défaut pour un objet Window, Frame, Dialog.

#& POO JAVA: GI2

 GRIDLAYOUT (GRILLE DE
RANGEMENT)
Ce gestionnaire permet d'imposer un positionnement des composants en
les plaçant dans les cases d'une grille rectangulaire. Il ajoute les
composants en les alignant sur le panneau courant, ligne par ligne et de
gauche à droite. Toutes les cases de cette grille ont les mêmes
dimensions.
Constructeurs
grille verticale à une seule colonne GridLayout();
grille de dimension donnée public GridLayout(int nb_lignes, int
nb_colonnes);
définition en plus des espacements entre les éléments public GridLayout(int
nb_lignes, int nb_colonnes, int espace_h, int espace_v);

#' POO JAVA: GI2

 GRIDLAYOUT

#( POO JAVA: GI2

 GRIDBAGLAYOUT

Un gestionnaire GridBagLayout est plus puissant, mais bien plus complexe

que les précédents. Il se base sur un quadrillage imaginaire du conteneur
tel que l'espace occupé par chaque composant soit une région
rectangulaire formée par la réunion d'un certain nombre de cases de ce
quadrillage.
Lors de son ajout au conteneur, chaque composant est associe a une
certaine contrainte qui spécifie quelles cases du quadrillage imaginaire le
composant occupe et comment il les occupe. Ensemble, toutes ces
contraintes définissent les dimensions des lignes et des colonnes du
quadrillage.

#) POO JAVA: GI2

 GRIDBAGLAYOUT

$* POO JAVA: GI2

 GRIDBAGCONSTRAINTS
GradBagLayout est une ardoise blanche, les contraintes attachées à
chaque composant déterminent la manière dont GradBagLayout affiche
ses composants.
Les contraintes sont des instances de la classe GridBagConstraints, dont
les principaux champs sont :
gridx : numero de la colonne du quadrillage (la premiere colonne porte le
numero 0) ou se place l'angle superieur gauche du composant.
gridy : numero de la ligne du quadrillage (la premiere ligne porte le numero
0) ou se place l'angle superieur gauche du composant.

$! POO JAVA: GI2

 GRIDBAGCONSTRAINTS
gridheight : nombre de lignes du quadrillage sur lesquelles le composant
s'étend.
gridwidth : nombre de colonnes du quadrillage sur lesquelles le composant
s'etend.
weightx : nombre exprimant la largeur de la colonne que le composant
occupe ; peu importe l'unité, à condition que ce soit la même pour toutes
les colonnes. // pour gérer la distribution de l’espace supplémentaire.
Mettez 0 si ce composant s'entend sur plusieurs colonnes ou si la largeur
peut se déduire de la contrainte d'un autre composant de cette colonne.
weighty : nombre exprimant la hauteur de la ligne que le composant
occupe ; peu importe l'unité, à condition que ce soit la même pour toutes
les lignes.
Mettez 0 si ce composant s'étend sur plusieurs lignes ou si la hauteur peut
se déduire de la contrainte d'un autre composant de cette ligne.
$" POO JAVA: GI2
 GRIDBAGCONSTRAINTS
fill : indication de la manière dont le composant doit remplir sa zone. Les
valeurs possibles sont :
- GridBagConstraints.NONE : le composant doit garder sa taille propre,
- GridBagConstraints.HORIZONTAL : le composant doit remplir toute la
largeur de sa zone,
- GridBagConstraints.VERTICAL : le composant doit remplir toute la hauteur
de sa zone,
- GridBagConstraints.BOTH : le composant doit remplir toute sa zone.
anchor : position du composant dans sa zone, s'il ne la remplit pas
entièrement. Les valeurs possibles sont :
GridBagConstraints.NORTH (au nord), GridBagConstraints.NORTHEAST (au
nord-est), GridBagConstraints.EAST (a l'est),
GridBagConstraints.SOUTHEAST (au sud-est), etc.

$# POO JAVA: GI2

 CARDLAYOUT
Le gestionnaire de positionnement CardLayout est significativement
différent des autres gestionnaires, tandis que les autres gestionnaires
affichent tous les composants à la fois, CardLayout affiche seulement un
composant à chaque fois.
Quelques méthode :
next(Container parent) // accéder au composant suivant du conteneur
parent
show(Container parent, String name) // accéder au composant du
conteneur qui a été ajouter par le nom name avec la méthode add(String
name, Component comp) définie dans java.awt.Container

$$ POO JAVA: GI2

 CARDLAYOUT

$% POO JAVA: GI2

 COMPLEXE LAYOUTMANAGER

Les GridBagLayout ne sont pas les seuls outils pour la construction de

gestionnaires d'interfaces graphiques complexes. Une autre manière de
monter de telles interfaces, plus souple et plus simple, consiste a
imbriquer plusieurs panneaux (objets Panel) les uns dans les autres,
chacun muni d'un gestionnaire de positionnement adéquat.
Voir l’exemple suivant :

$& POO JAVA: GI2

 COMPLEXE LAYOUTMANAGER

$' POO JAVA: GI2

 GESTION MANUELLE DE
POSITIONNEMENT
il est possible (mais non recommandé) de se passer complètement de gestionnaire
de disposition. Cela doit être explicitement demandé, par l'instruction
conteneur.setLayout(null);
A la suite de cette instruction, chaque composant devra être explicitement
dimensionne et positionne lors de son ajout au conteneur (cela génère
énormément de calculs avec des pixels !).
Les methodes pour cela sont :
void setLocation(int x, int y) et void setLocation(Point p)
définit la position du coin supérieur gauche du composant, relativement a une
origine qui est placée au coin supérieur gauche du conteneur.
void setSize(int width, int height), void setSize(Dimension d)
définit les dimensions du composant,
void setBounds(int x, int y, int width, int height) et void setBounds(Rectangle
r)
remplit simultanément les fonctions de setLocation et celles de setSize.

$( POO JAVA: GI2

 MENUS AWT

La création de menus se fait très simplement en Java, à l'aide de 4 classes

di érentes qui héritent toutes de la classe MenuComponent. Une barre de
menu se compose d'une instance de la classe MenuBar auquel vous
pouvez ajouter grâce à la méthode add () un ou plusieurs menus instances
de la classe Menu. Finalement, vous pouvez ajouter à chaque menu grâce
à la méthode add () de la classe Menu un ensemble d'éléments instances
des classes MenuItem (pour créer des éléments simples),
CheckboxMenuItem (pour créer des éléments à cocher) ou Menu (pour
créer un sous-menu).

$) POO JAVA: GI2

ff
 MENUS AWT
A

%* POO JAVA: GI2

 LES MENUS AWT
La classe Frame est la seule classe de fenêtre pour laquelle vous pouvez
spécifier une barre de menu, grâce à la méthode setMenuBar (). Par
conséquent, vous ne pouvez pas donner de menu aux Windows,Dialog …
puisque leurs classes n'héritent pas de la classe Frame.

setMenuBar ( méthode définie dans la classe Frame)

public void setMenuBarn(MenuBar mb)
Modifie La barre de menu pour cette frame par la barre de menue
spécifiée.
Paramètres:
mb - the menu bar being set. Si ce paramètre est null, dans ce cas la
barre de menue courante est supprimer.

%! POO JAVA: GI2

 MENUCOMPONENT
La classe MenuComponent qui est abstract est la super classe de toutes
les classes de composants utilisables dans un menu (MenuBar, MenuItem,
Menu et CheckboxMenuItem). Elle ressemble dans le principe à la classe
Component en plus simple.
Constructeur
public MenuComponent ()
Quelques Méthodes
public MenuContainer getParent () // retourne le conteneur parent de ce
menu public Font getFont () et public void setFont (Font font)
Ces méthodes permettent d'interroger ou de modifier la police de caractère
utilisée pour l'affichage d'un composant de menu.
public String toString ()
Cette méthodes redéfinit la méthode toString() de la classe Object affiche
une chaine de caractères décrivant le composant de menu.

%" POO JAVA: GI2

 MENUBAR
Cette classe qui dérive de la classe MenuComponent, est la classe du package
java.awt qui permet de créer et de manipuler une barre de menu. Une fois que
vous avez créez une barre de menu vous pouvez y ajouter un ou plusieurs menus.
La méthode setMenuBar () de classe Frame permet de spécifier la barre de menu
que doit utiliser une fenêtre.
Constructeur
public MenuBar ()
Quelques Méthodes
public Menu add (Menu menu) // Permet d'ajouter un menu à une barre de menu.
public void remove (int index)
public void remove (MenuComponent menu)
Ces méthodes permettent de supprimer un menu d'une barre de menu, soit en
donnant son numéro d'ordre index, soit en donnant directement l'instance de
menu à supprimer.

%# POO JAVA: GI2

 MENUBAR
public int getMenuCount()
Renvoie le nombre de menus courant d'une barre de menu.
public Menu getMenu (int index)
Renvoie le menu dont le numéro d'ordre est index.
public Menu getHelpMenu ()
public void setHelpMenu (Menu m)
Ces méthodes permettent d'interroger ou de modifier le menu d'aide.

%$ POO JAVA: GI2

 MENUITEM
Cette classe qui dérive de la classe MenuComponent, est la classe du package
java.awt qui permet de créer et de manipuler un élément simple de menu. Un
élément de menu a un label qui est le texte affiché dans le menu et peut être
éventuellement grisé pour indiquer qu'il n'est pas utilisable à un moment donné.
Constructeur
public MenuItem (String label)
Ce constructeur permet de donner un label au nouveau menu créé.
Quelques Méthodes
public String getLabel ()
public void setLabel (String label)
Public void addActionListener (ActionListener l) // enregistre l’auditeur l pour
écouter des événement de type ActionEvent

%& POO JAVA: GI2

 MENUITEM
Ces méthodes permettent d'interroger ou de modifier le label d'un menu.
public boolean isEnabled ()
Renvoie true si un élément de menu est utilisable.
public void enable ()
public void disable ()
public void enable (boolean cond)
Vous pouvez rendre utilisable ou inutilisable un composant grâce à ces
méthodes. Un élément de menu inutilisable (disabled) est généralement
grisé.
public String paramString ()
Méthode de la classe MenuComponent, redéfinie pour renvoyer une chaîne
de caractères décrivant l'élément de menu.

%' POO JAVA: GI2

 MENU
Cette classe qui dérive des classes MenuItem et MenuComponent est la
classe du package java.awt qui permet de créer et de manipuler un menu
ou un sous-menu. Un menu a un label et peut contenir un ou plusieurs
éléments ; les éléments qui sont eux-mêmes des instances de la classe
Menu deviennent des sous-menus.
Constructeurs
public Menu (String label)
Quelque Méthodes
public void setEnabled(boolean b)
Permet d’activer / désactiver un menu

%( POO JAVA: GI2

 MENU
public int countItems ()
Renvoie le nombre d'éléments d'un menu.
public MenuItem getItem (int index)
Renvoie l'élément du menu de numéro d'ordre index.
public MenuItem add (MenuItem menuItem)
public void add (String label)
Ces méthodes permettent d'ajouter un élément à un menu.
public void addSeparator ()
Permet d'ajouter un séparateur à un menu. Equivalent à l'appel de la méthode add
("-").
public void remove (int index)
public void remove (MenuComponent item)
Ces méthodes permettent de retirer d'un menu l'élément de numéro d'ordre index
ou l'élément item.

%) POO JAVA: GI2

 CHECKBOXMENUITEM
Cette classe qui dérive des classes MenuItem et MenuComponent est la classe du
package java.awt qui permet de créer et de manipuler un élément de menu à
cocher. Comme un composant de classe Checkbox, ce type d'élément de menu a
un état coché ou non.
Constructeur
CheckboxMenuItem()
public CheckboxMenuItem (String label)
CheckboxMenuItem(String label, boolean Etat)
Quelques Méthodes
public boolean getState ()
public void setState (boolean t)
Ces méthodes permettent d'interroger ou de modifier l'état coché ou non de
l'élément de menu.
public String paramString ()
Méthode de la classe MenuComponent, redéfinie pour renvoyer une chaîne de
caractères décrivant l'élément de menu à cocher.

&* POO JAVA: GI2

 CHECKBOXMENUITEM

&! POO JAVA: GI2

 CONCLUSION

Dans ce chapitre nous avons détaillé le package java.awt :

Les controles : Label, Checkbox, Button, List, Choice, TextField, TextArea

Les conteneurs : Wimdow, Panel, Dialog, Frame, FileDialog, ScrollPane

Les gestionnaires de positionnement : FlowLayout, BorderLayout,

CardLayout, GrideLayout, GridBagLayout

Les Menus : MenuBar, Menu, MenuItem, CheckboxMenuItem

&" POO JAVA: GI2