Interfaces Graphiques en Java 2019 PDF

INTERFACES GRAPHIQUES EN JAVA
-----
Les interfaces graphiques assurent le dialogue entre les utilisateurs et une application.
Dans un premier temps, Java propose l'API AWT pour créer des interfaces graphiques.
Depuis, Java propose une nouvelle API nommée Swing. Ces deux API peuvent être
utilisées pour développer des applications ou des applets. Les classes du toolkit AWT
(Abstract Windows Toolkit) permettent d'écrire des interfaces graphiques indépendantes
du système d'exploitation sur lesquelles elles vont fonctionner. Cette librairie utilise le
système graphique de la plateforme d'exécution (Windows, MacOS, X-Window) pour
afficher les objets graphiques. Le toolkit contient des classes décrivant les composants
graphiques, les polices, les couleurs et les images.
Les deux classes principales de AWT sont Component et Container. Chaque type d'objet
de l'interface graphique est une classe dérivée de Component. La classe Container, qui
hérite de Component est capable de contenir d'autres objets graphiques (tout objet
dérivant de Component).
Quelques classes de AWT et leur description

Classe Description
Applet La classe de base de toutes les applets
Button Bouton; son click provoque un événement
Component La classe de base de toutes les classes de
l’interface graphique
Container Les conteneurs sont des objets graphiques
qui peuvent contenir d'autres objets
graphiques, incluant éventuellement des
conteneurs.
Un composant graphique doit toujours être
incorporé dans un conteneur
Frame Une fenêtre graphique munie d’une barre
de titre
Label Utilisée pour les étiquettes
Panel Un conteneur invisible
TextField Pour afficher et entrer du texte
Window Classe de base de la classe Frame
Hiérarchie de quelques classes de AWT et de SWING :
Component
Button
Label
Container
Panel
Applet
JApplet
Window
Frame
JFrame
JComponent
JButton
JLabel
JPanel
Pour utiliser un composant, il faut créer un nouvel objet représentant le composant et

l'ajouter à un objet de type conteneur qui existe, avec la méthode add().
Exemple: ajout d'un bouton dans une applet
import java.applet.*;
import java.awt.*;
public class AppletButton extends Applet
{
Button b = new Button("Bouton");
public void init()
{
super.init();
this.add(b);
}
}
1. Utilisation des classes de l'AWT

1.1. Création d’une fenêtre munie d’un bouton
Notre premier exemple consiste en une frame munie d’un bouton. Pour cela on va utiliser
les classes Frame et Button de AWT.
import java.awt.*;
public class AWTFrameAvecBouton extends Frame
{
public AWTFrameAvecBouton()
{
//Créer une instance de la classe Button avec "Fermer" comme caption
Button bt = new Button("Fermer");
// ajouter l'instance de Button à l'instance du conteneur Frame
//La méthode add() est héritée de la classe Component
this.add(bt);
//Etablir les dimensions du frame
//La méthode setSize() est héritée de la classe Component
this.setSize(300,150);
// Donner un titre au frame
//La méthode setTitle() est héritée de la classe Frame
this.setTitle("Frame AWT avec un bouton");
// Rendre le Frame visible
// La méthode setVisible() est héritée de la classe Component
this.setVisible(true);
}
public static void main(String args[])
{
// Créer une inatance de la classe Frame
AWTFrameAvecBouton frameAvec Bt = new AWTFrameAvecBouton();
}
}
1.2. Utilisation de gestionnaires de mise en forme
Le package AWT possède plusieurs classes appelées gestionnaires de forme. Ces

gestionnaires de forme sont responsables de la disposition des composants placés dans
un conteneur. Les gestionnaires de formes les plus fréquemment utilisés sont :
FlowLayout, BorderLayout, GridLayout. Pour utiliser un gestionnaire forme, il faut
l’instancier et passer cette instance en argument à la méthode setLayout(). La méthode
setLayout() est héritée de la classe container.
Remarque :
Si le gestionnaire de mise en forme n’est pas précisé, Java utilise BorderLayout pour les
instances de Frame et FlowLayout pour les instances de Panel. Ainsi, notre exemple
précédent a utilisé par défaut, le gestionnaire de forme BorderLayout.
1.1.1. BorderLayout
BorderLayout dispose les composants suivant l’un des 4 bords du conteneur ou au centre.
On choisit l’emplacement d’un composant en fournissant en argument de la méthode
add() l’une des constantes entières suivantes.
Constante symbolique Emplacement

correspondant
BorderLayout.NORTH En haut
BorderLayout.SOUTH En bas
BorderLayout.EAST A droite
BorderLayout.WEST A gauche
BorderLayout.CENTER Au centre
Exemple
this.add(bt, BorderLayout.WEST);
Si aucune valeur n’est precise à la méthode add(), le composant est place au centre.
2.1.2. FlowLayout
Le gestionnaire de mise en forme FlowLayout dispose les composants les uns à la suite
des autres, sur une même ligne. Lorsqu’une ligne ne possède plus suffisamment de place,
l’affichage se poursuit sur la ligne suivante. Contrairement à ce qui se produit avec
BorderLayout, la taille des composants est respectée. Lors de la construction d’un
gestionnaire FlowLayout, on peut spécifier un paramètre d’alignement d’une ligne de
composants par rapport aux bords verticaux de la fenêtre. Pour cela, on utilise l’une des
constantes entières suivantes :
Constante symbolique Alignement correspondant de la ligne de

composants
FlowLayout.LEFT A gauche (valeur par défaut)
FlowLayout.RIGHT A droite
FlowLayout.CENTER Au centre
Exemple :
this.setLayout(new FlowLayout(FlowLayout.CENTER)) ;
1.3. Gestion des événements

1.3.1. Introduction
N'importe quelle interface graphique doit interagir avec l'utilisateur et donc réagir à
certains événements. En Java, tout événement possède une source. Il s’agit de l’objet lui
ayant donné naissance : bouton, fenêtre, article de menu…
Pour traiter un événement, on associe à la source un objet de son choix dont la classe
implémente une interface particulière correspondant à une catégorie d’événements. On
dit que cet objet est un écouteur de cette catégorie d’événement.
Les interfaces EventListener permettent à un composant de générer des événements

utilisateurs. Une classe doit contenir une interface écouteur pour chaque type de
composant. Parmi les écouteurs on a :
 ActionListener : clic de souris ou enfoncement de la touche Enter
 ItemListener : utilisation d'une liste ou d'une case à cocher
 MouseMotionListener : evénément de souris
 WindowListener : événement de fenêtre
L'ajout d'une interface EventListener impose plusieurs ajouts dans le code :
1. importer le groupe de classe java.awt.event
import java.awt.event.*;
2. la classe doit déclarer qu'elle utilisera une ou plusieurs interfaces d'écoute
public class AppletAction extends Applet implements

ActionListener{
Pour déclarer plusieurs interfaces, il suffit de les séparer par des virgules
public class MonApplet extends Applet implements ActionListener,

MouseListener {
3. Appel à la méthode addXXX() pour enregistrer l'objet qui va gérer les
évenements XXX du composant.
Il faut configurer le composant pour qu'il possède un "écouteur" pour l'événement

utilisateur concerné.
Exemple: création d'un bouton capable de réagir à un événement

Button b = new Button("bouton");
b.addActionListener(this);
4. implémenter les méthodes déclarées dans les interfaces
Chaque auditeur possède des méthodes différentes qui sont appelées pour traiter
leurs évenéments. Par exemple, l'interface ActionListener envoie des évenements
à une méthode nommée actionPerformed().
Exemple:
public void actionPerformed(ActionEvent evt)
{
//insérer ici le code de la méthode
};
Pour identifier le composant qui a généré l'evénement il faut utiliser la méthode

getActionCommand() de l'objet ActionEvent fourni en paramètre de la méthode :
Exemple:
String composant = evt.getActionCommand();
getActionCommand() renvoie une chaîne de caractères. Si le composant est un

bouton, alors il renvoie le texte du bouton, si le composant est une zone de saisie,
c'est le texte saisie qui sera renvoyé (il faut appuyer sur "Entrer" pour générer
l'événement), etc ...
La méthode getSource() renvoie l'objet qui a généré l'événement. Cette méthode

est plus sure que la précédente
Exemple:
Button b = new Button(" Bouton ");
...
void public actionPerformed(ActionEvent evt)
{
Object source = evt.getSource();
if (source == b) // action à effectuer
}
La méthode getSource() peut être utilisé avec tous les évenements utilisateur.
1.3.2. L'interface ActionListener
l'interface ActionListener envoie des événements à une méthode nommée

actionPerformed().
Pour identifier le composant qui a généré l'événement il faut utiliser la méthode

getActionCommand() de l'objet ActionEvent fourni en paramètre de la méthode :
getActionCommand() renvoie une chaîne de caractères. Si le composant est un

bouton, alors il renvoie le texte du bouton, si le composant est une zone de saisie,
c'est le texte saisie qui sera renvoyé, etc ...
La méthode getSource() renvoie l'objet qui a généré l'événement. Cette méthode

est plus sure que la précédente .
Exemple: Exemple complet qui affiche le composant qui a généré

l'événement
import java.awt.*;
public class AppletAction extends Applet implements
ActionListener
{
public void actionPerformed(ActionEvent toto)

{
String composant = toto.getActionCommand();
showStatus("Action sur le composant : " + composant);
}
public void init()

{
super.init();
Button b1 = new Button("bouton 1");

b1.addActionListener(this);
add(b1);

add(b2);

add(b3);
}
}
1.3.3. L'interface ItemListener
Cette interface permet de réagir à la sélection de cases à cocher et de liste d'options. Pour
qu'un composant génère des évenements, il faut utiliser la méthode addItemListener().
Exemple :
Checkbox cb = new Checkbox(" choix ",true);
cb.addItemListener(this);
Ces évenements sont reçus par la méthode itemStateChanged() qui attend un objet de
type ItemEvent en argument.
Pour déterminer si une case à cocher est sélectionnée ou inactive, utiliser la méthode
getStateChange() avec les constantes ItemEvent.SELECTED ou
ItemEvent.DESELECTED.
Exemple:
import java.awt.*;
public class AppletItem extends Applet implements ItemListener

{
public void init()

{
super.init();
Checkbox cb = new Checkbox("choix 1", true);
cb.addItemListener(this);
add(cb);
}
public void itemStateChanged(ItemEvent toto)

{
int status = toto.getStateChange();
if (status == ItemEvent.SELECTED)
showStatus("choix sélectionné");
else
showStatus("choix non sélectionné");
}
}
Pour connaitre l'objet qui a généré l'événement, il faut utiliser la méthode getItem().
Pour déterminer la valeur sélectionnée dans une combobox, il faut utiliser la méthode
getItem() et convertir la valeur en chaîne de caractères.
Exemple:
import java.awt.*;
public class AppletItem2 extends Applet implements ItemListener

{
public void init()

{
Choice c = new Choice();
c.add("choix 1");
c.add("choix 2");
c.add("choix 3");
c.addItemListener(this);
this.add(c);
}
public void itemStateChanged(ItemEvent item)

{
Object obj = item.getItem();
String selection = (String)obj;
showStatus("choix : "+selection);
}
}
1.3.4. L'interface TextListener
Cette interface permet de réagir aux modifications de la zone de saisie ou du texte.

La méthode addTextListener() permet à un composant de texte de générer des
événements utilisateur. La méthode TextValueChanged() reçoit les évenements.
Exemple :
import java.awt.*;
public class AppletText extends Applet implements TextListener

{
public void init()

{
super.init();
TextField t = new TextField(" ");

t.addTextListener(this);
this.add(t);
}
public void textValueChanged(TextEvent txt)

{
Object source = txt.getSource();
showStatus("saisi = "+((TextField)source).getText());
}
}
1.3.5. L'interface MouseMotionListener
La méthode addMouseMotionListener() permet de gérer les évenements liés à des

mouvements de souris. Les méthodes mouseDragged() et mouseMoved() reçoivent les
évenements.
Exemple:
import java.awt.*;
public class AppletMvmt extends Applet implements MouseMotionListener

{
private int x;
private int y;
public void init()

{
super.init();
this.addMouseMotionListener(this);
}
public void mouseDragged(MouseEvent e)

{
}
public void mouseMoved(MouseEvent e)

{
x = e.getX();
y = e.getY();
showStatus("x = " +x+ " ; y = "+y);
}
}
1.3.6. L'interface MouseListener
Cette interface permet de réagir aux clics de souris. Les méthodes de cette interface sont :
 public void mouseClicked(MouseEvent e);

 public void mousePressed(MouseEvent e);
 public void mouseReleased(MouseEvent e);
 public void mouseEntered(MouseEvent e);
 public void mouseExited(MouseEvent e);
Exemple:
import java.awt.*;
public class AppletSouris extends Applet implements MouseListener

{
int nbClick = 0;
public void init()

{
super.init();
addMouseListener(this);
}
public void mouseClicked(MouseEvent e)

{
nbClick++;
//repaint();
}
public void mouseEntered(MouseEvent e)

{}
public void mouseExited(MouseEvent e)

{}
public void mousePressed(MouseEvent e)

{}
public void mouseReleased(MouseEvent e)

{}
public void paint(Graphics g)

{
super.paint(g);
g.drawString("Nombre de clics : "+nbClick,10,10);
}
}
Une classe qui implémente cette interface doit définir ces 5 méthodes. Si toutes les
méthodes ne doivent pas être utilisées, il est possible de définir une classe qui hérite de
MouseAdapter. Cette classe fournit une implémentation par défaut de l'interface
MouseListener.
Exemple:
class GestionClics extends MouseAdapter
{
public void mousePressed(MouseEvent e)

{
//traitement
}
}
Dans le cas d'une classe qui hérite d'une classe Adapter, il suffit de redéfinir la ou les
méthodes qui contiendront du code pour traiter les événements concernés. Par défaut, les
différentes méthodes définies dans l'Adapter ne font rien.
Un objet de cette nouvelle classe ainsi définie doit être passé en paramètre à la méthode
addMouseListener() au lieu de this qui indiquait que la classe répondait elle-même à
l'événement.
1.3.7. L'interface WindowListener
La méthode addWindwowListener() permet à un objet Frame de générer des événements.

Les méthodes de cette interface sont :
 public void windowOpened(WindowEvent e)

 public void windowClosing(WindowEvent e)
 public void windowClosed(WindowEvent e)
 public void windowIconified(WindowEvent e)
 public void windowDeinconified(WindowEvent e)
 public void windowActivated(WindowEvent e)
 public void windowDeactivated(WindowEvent e)
windowClosing est appelée lorque l'on clique sur la case système de fermeture de la
fenêtre.
windowClosed est appelé après la fermeture de la fenêtre : cette méthode n'est utile que si
la fermeture de la fenêtre n'entraine pas la fin de l'application.
Exemple:Utilisation de l’interface WindowListener
Nous allons reprendre l’exemple du point 1.1 en lui appliquant l’écouteurs

WindowListener
import java.awt.*;
public class AWTFrameAvecBouton1 extends Frame implements WindowListener
{
public AWTFrameAvecBouton1()
{
this.add(bt);
// Enregistrer l’instance de frame comme son propre écouteur
this.addWindowListener(this);
}

{
// Créer une inatance de la classe Frame
AWTFrameAvecBouton1 frameAvecBt = new
AWTFrameAvecBouton1();
}
/* Il faut redéfinir les 7 méthodes suivantes si l’interface WindowListener

est implémentée */
public void windowClosing(WindowEvent ev)

{fermerFenetre();}
public void windowClosed(WindowEvent ev) {}
public void windowDeiconified(WindowEvent ev){}
public void windowIconified(WindowEvent ev){}
public void windowActivated(WindowEvent ev){}
public void windowDeactivated(WindowEvent ev){}
public void windowOpened(WindowEvent ev){}
public void fermerFenetre()

{
this.dispose();
System.exit(0);
}
}
Exemple: utilisation d’une classe « adapter»

Au lieu d’implémenter l’interface WindowListener, on peut utiliser un «adapter»
import java.awt.*;
public class AWTFrameAvecBouton2 extends Frame
{
{
this.add(bt);
// Créer une instance de la classe « adaptateur » Fermeture
Fermeture gestEvnt = new Fermeture(this) ;
// Enregistrer l’instance gestEvnt comme écouteur
this.addWindowListener(gestEvnt);
}

{
// Créer une instance de la classe Frame
}

{
this.dispose();
System.exit(0);
}
}
// la classe Fermeture dérive de la classe WindowAdapter

class Fermeture extends WindowAdapter
{
AWTFrameAvecBouton2 fenetreAfermer;
public Fermeture(AWTFrameAvecBouton2 fn)
{ fenetreAfermer =fn;}
{fenetreAfermer.fermerFenetre();}
}
Exemple: Utilisation de classe anonyme interne
La troisième manière de gérer les événements est l’utilisation de classe anonyme interne
qu’on définit à l’intérieur d’une autre classe. La classe anonyme n’a pas de nom.
L’utilisation de classe anonyme permet de simplifier le code pour la gestion des
événements surtout dans le cas de WindowEvent.
La structure de définition d’une classe anonyme interne se présente comme ci-après :
new nom_de_la_classe_de_base
{
corps de la classe anonyme interne
}
Pour notre exemple on aura :
this.addWindowListener
( // Début de la dénition de la classe anonyme interne
new WindowAdapter() // WindowAdapter est la classe de base
{
{ fermerFenetre();}
}
);
L’exemple complet avec classe anonyme interne se présente comme suit:
import java.awt.*;
public class AWTFrameAvecBouton3 extends Frame
{
{
this.add(bt);
// Création de classe anonyme interne

(// Début de la dénition de la classe anonyme interne
new WindowAdapter() // WindowAdapter est la classe de base
{
{ fermerFenetre();}
}
);
}

{
// Créer une instance de la classe Frame
}

{
this.dispose();
System.exit(0);
}
}
1.4. Utilisation de plusieurs composants AWT
Nous allons développer une classe qui comportera une Frame avec 3 boutons et 1 zone
de saisie et d’une étiquette. Nous aurons besoin de l’interface ActionListener pour les
boutons mais pour fermer la fenêtre, nous allons utiliser une classe anonyme interne,
donc pas besoin d’implémenter WindowListener.
import java.awt.* ;
import java.awt.event.* ;
public class AWTFrameEtComposants extends Frame implements ActionListener
{
// Variables référence des boutons, de la zone de saisie,
// et de l'étiquetter
Button btAfficher, btEffacer, btFermer ;
TextField tfmsg ;
Label lblmsg;

{
// Créer une instance de AWTFrameEtCoposants
AWTFrameEtComposants frComp = new AWTFrameEtComposants() ;
}
// Constructeur
public AWTFrameEtComposants()
{
// Créer les boutons et les zones de saisie
btAfficher = new Button(" Afficher") ;
btEffacer = new Button("Effacer");
btFermer = new Button("Fermer");
lblmsg = new Label("Message");
tfmsg = new TextField(15);
// Créer 2 instances de Panel ; A défaut le gestionnaire
//de forme FlowLayout
Panel phaut = new Panel() ;
Panel pbas = new Panel() ;
// Ajout de l’étiquette et de la zone de saisie au panel de haut
phaut.add(lblmsg) ;
phaut.add(tfmsg) ;
// Ajout des boutons au panel de bas
pbas.add(btAfficher) ;
pbas.add(btEffacer) ;
pbas.add(btFermer) ;
// Ajout du panel au frame ; le gestionnaire
//de forme à défaut, BorderLayout
this.add("North",phaut) ;
this.add("South",pbas) ;
// Enregistrer le Frame comme écouteur des boutons
btAfficher.addActionListener(this) ;
btEffacer.addActionListener(this) ;
btFermer.addActionListener(this);
this.setTitle("Plusieurs contrôles AWT");
this.setVisible(true) ;
// Créer une classe anonyme interne pour

//gérer la fermeture de la fenêtre
(//Début de la définition de la classe anonyme
new WindowAdapter() // Classe de base
{
{fermerFenetre();}
} // Fin de la définition de la classe anonyme
) ; // Fin de l’argument envoyé à la méthode
addWindowListener
}
// La méthode actionPerformed est appelée quand on clique sur un bouton
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == btAfficher)
{ afficherMessage();}
if(e.getSource() == btEffacer)
{ effacerMessage();}
if(e.getSource() == btFermer)
{ fermerFenetre();}
}
public void afficherMessage()
{ tfmsg.setText("Coucou, Bonjour") ;}
public void effacerMessage()
{ tfmsg.setText(" ") ;}
{this.dispose() ; System.exit(0) ;}
2. Utilisation de l’API SWING

SWING est une nouvelle version améliorée d’AWT. La procédure à suivre pour utiliser
un composant Swing est identique à celle des composants de la bibliothèque AWT : créer
le composant en appelant son constructeur, appeler les méthodes du composant si
nécessaire pour le personnaliser et l'ajouter dans un conteneur. Swing utilise la même
infrastructure de classes que AWT, ce qui permet de mélanger des composants Swing et
AWT dans la même interface. Sun recommande toutefois d'éviter de les mélanger car
certains peuvent ne pas être restitués correctement.
2.1. Packages Swing

Swing contient plusieurs packages :
package principal : il contient les interfaces, les

javax.swing
principaux composants, les modèles par défaut
javax.swing.border Classes représentant les bordures
Classes définissant un composant pour la sélection
javax.swing.colorchooser
de couleurs
Classes et interfaces pour les événements
javax.swing.event spécifiques à Swing. Les autres événements sont
ceux de AWT (java.awt.event)
Classes définissant un composant pour la sélection
javax.swing.filechooser
de fichiers
Classes et interfaces génériques pour gérer
javax.swing.plaf
l'apparence
javax.swing.plaf.basic Classes et interfaces de base pour gérer l'apparence
Classes et interfaces pour définir l'apparence Metal
javax.swing.plaf.metal
qui est l'apparence par défaut
Classes définissant un composant pour la
javax.swing.table
présentation de données sous forme de tableau
Classes et interfaces de bases pour les composants
javax.swing.text
manipulant du texte
javax.swing.text.html Classes permettant le support du format HTML
javax.swing.text.html.parser Classes permettant d'analyser des données au
format HTML
javax.swing.text.rtf Classes permettant le support du format RTF
Classes définissant un composant pour la
javax.swing.tree
présentation de données sous forme d'arbre
Classes permettant d'implémenter les fonctions
javax.swing.undo
annuler/refaire
2.2. Conversion d’une interface AWT en SWING

Nous allons adapter la classe AWTFrameEtComposants au SWING.
- Les composants de SWING résident dans le package javax.swing ; (import
javax.swing.*)
- La classe va dériver JFrame au lieu de Frame
- Les classes Button, Label, TextField, et Panel seront remplacées par JButton, JLabel,
JTextField, et JPanel
- Il faudra ajouter une nouvelle instruction, afin d’obtenir la référence à JFrame pour
invoquer la méthode add et ajouter les instances de Panel au frame.
import java.awt.* ;
import javax.swing.* ;
public class SWINGFrameEtComposants extends JFrame implements ActionListener
{
// Variables référence des boutons,de la zone de saisie,
// et de l'étiquette
JButton btAfficher, btEffacer, btFermer ;
JTextField tfmsg ;
JLabel lblmsg;

{
// Créer une instance de SWINGFrameEtComposants
SWINGFrameEtComposants frComp = new SWINGFrameEtComposants () ;
}
// Constructeur
public SWINGFrameEtComposants ()
{
// Créer les boutons et les zones de saisie
btAfficher = new JButton("Afficher") ;
btEffacer = new JButton("Effacer");
btFermer = new JButton("Fermer");
lblmsg = new JLabel("Message");
tfmsg = new JTextField(15);
// Créer 2 instances de JPanel ; A défaut le
//gestionnaire de forme FlowLayout
JPanel phaut = new JPanel() ;
JPanel pbas = new JPanel() ;
// Ajout de l’étiquette et de la zone de saisie au panel de haut
phaut.add(lblmsg) ;
phaut.add(tfmsg) ;
// Ajout des boutons au panel de bas
pbas.add(btAfficher) ;
pbas.add(btEffacer) ;
pbas.add(btFermer) ;
// Ajout du panel au frame ; le gestionnaire
//de forme à défaut, BorderLayout
Container c = this.getContentPane() ;
c.add("North",phaut) ;
c.add("South",pbas) ;
// Enregistrer le Frame comme écouteur des boutons
btAfficher.addActionListener(this) ;
btEffacer.addActionListener(this) ;
btFermer.addActionListener(this);
this.setTitle("Plusieurs contrôles SWING");
// Créer une classe anonyme interne pour gérer

//la fermeture de la fenêtre
{
{fermerFenetre();}
) ; // Fin de l’argument envoyé à la méthode
addWindowListener
}
{
if(e.getSource() == btAfficher)
if(e.getSource() == btEffacer)
if(e.getSource() == btFermer)
{ fermerFenetre();}
}

2.3. Ajout de menu déroulant
Un menu déroulant SWING est constitué d’instance d’au moins 3 classes : JMenuBar,
JMenu, JMenuItem. Pour ajouter un menu déroulant à un frame, il faut dans un premier
temps créer une instance de JMenuBar, ensuite une instance de JMenu et puis de
JMenuItem. On ajoute les instances de JMenuItem aux instances de JMenu et de JMenu à
JMenuBar .
On peut créer de touche de raccourci pour chaque menu en faisant appel à la méthode
setMnemonic de JMenu
import java.awt.* ;
import javax.swing.* ;
public class MenuSwing extends JFrame implements ActionListener
{
JMenuItem mnAfficher, mnEffacer, mnFermer ;

JTextField tfmsg ;
JLabel lblmsg;

{
// Créer une instance de MenuSwing
MenuSwing fr = new MenuSwing() ;
}
// Constructeur
public MenuSwing()
{
// Créer barre de menu, menu et menu item
JMenuBar barreMn = new JMenuBar();
JMenu mnFichier = new JMenu("Fichier");
JMenu mnAide = new JMenu("Aide");
mnAfficher = new JMenuItem("Afficher");
mnEffacer = new JMenuItem("Effacer");
mnFermer = new JMenuItem("Fermer");
mnFichier.setMnemonic('F');
mnAide.setMnemonic('A');
// ajouter la barre de menu au frame
this.setJMenuBar(barreMn);
// ajouter les menus à la barre de menu
barreMn.add(mnFichier);
barreMn.add(mnAide);
// Ajouter les menus Items aux menus
mnFichier.add(mnAfficher);
mnFichier.add(mnEffacer);
mnFichier.add(mnFermer);
lblmsg = new JLabel("Message");

tfmsg = new JTextField(15);
// Ajout de l'étiquette et de la zone de saisie au panel de haut

Container c = this.getContentPane() ;
c.setLayout(new FlowLayout());
c.add(lblmsg);
c.add(tfmsg);
// Enregistrer le frame comme écouteur des menus

mnAfficher.addActionListener(this);
mnEffacer.addActionListener(this);
mnFermer.addActionListener(this);
// this.setTitle("Plusieurs contrôles SWING");
// Créer une classe anonyme interne pour gérer la fermeture de la fenêtre

{
{fermerFenetre();}
) ; // Fin de l’argument envoyé à la méthode addWindowListener
}

{
if(e.getSource() == mnAfficher)
if(e.getSource() == mnEffacer)
if(e.getSource() == mnFermer)
{ fermerFenetre();}
}




Interfaces Graphiques en Java 2019 PDF

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

Interfaces Graphiques en Java 2019 PDF

Transféré par

Droits d'auteur :

Formats disponibles

INTERFACES GRAPHIQUES EN JAVA

Quelques classes de AWT et leur description

Hiérarchie de quelques classes de AWT et de SWING :

Pour utiliser un composant, il faut créer un nouvel objet représentant le composant et

Exemple: ajout d'un bouton dans une applet

1. Utilisation des classes de l'AWT

1.2. Utilisation de gestionnaires de mise en forme

Le package AWT possède plusieurs classes appelées gestionnaires de forme. Ces

Constante symbolique Emplacement

Constante symbolique Alignement correspondant de la ligne de

1.3. Gestion des événements

Les interfaces EventListener permettent à un composant de générer des événements

L'ajout d'une interface EventListener impose plusieurs ajouts dans le code :

1. importer le groupe de classe java.awt.event

2. la classe doit déclarer qu'elle utilisera une ou plusieurs interfaces d'écoute

public class AppletAction extends Applet implements

public class MonApplet extends Applet implements ActionListener,

Il faut configurer le composant pour qu'il possède un "écouteur" pour l'événement

Exemple: création d'un bouton capable de réagir à un événement

4. implémenter les méthodes déclarées dans les interfaces

Pour identifier le composant qui a généré l'evénement il faut utiliser la méthode

getActionCommand() renvoie une chaîne de caractères. Si le composant est un

La méthode getSource() renvoie l'objet qui a généré l'événement. Cette méthode

l'interface ActionListener envoie des événements à une méthode nommée

Pour identifier le composant qui a généré l'événement il faut utiliser la méthode

getActionCommand() renvoie une chaîne de caractères. Si le composant est un

La méthode getSource() renvoie l'objet qui a généré l'événement. Cette méthode

Exemple: Exemple complet qui affiche le composant qui a généré

public void actionPerformed(ActionEvent toto)

public void init()

Button b1 = new Button("bouton 1");

Button b2 = new Button("bouton 2");

Button b3 = new Button("bouton 3");

public class AppletItem extends Applet implements ItemListener

public void init()

public void itemStateChanged(ItemEvent toto)

public class AppletItem2 extends Applet implements ItemListener

public void init()

public void itemStateChanged(ItemEvent item)

1.3.4. L'interface TextListener

Cette interface permet de réagir aux modifications de la zone de saisie ou du texte.

public class AppletText extends Applet implements TextListener

public void init()

TextField t = new TextField(" ");

public void textValueChanged(TextEvent txt)

1.3.5. L'interface MouseMotionListener

La méthode addMouseMotionListener() permet de gérer les évenements liés à des

public class AppletMvmt extends Applet implements MouseMotionListener

public void init()

public void mouseDragged(MouseEvent e)

public void mouseMoved(MouseEvent e)

1.3.6. L'interface MouseListener

 public void mouseClicked(MouseEvent e);

public class AppletSouris extends Applet implements MouseListener

public void init()

public void mouseClicked(MouseEvent e)

public void mouseEntered(MouseEvent e)

public void mouseExited(MouseEvent e)

public void mousePressed(MouseEvent e)

public void mouseReleased(MouseEvent e)

public void paint(Graphics g)

public void mousePressed(MouseEvent e)

1.3.7. L'interface WindowListener