1 Les interfaces utilisateurs graphiques en Java
AWT (Abstract Windowing Toolkit) et Swing
2
AWT est le paquetage de base pour construire et
manipuler des interfaces utilisateurs graphiques,
parmi les paquetages originaux de Java.
les programmeurs sont plutôt encouragés à utiliser Swing
Swing est un nouveau paquetage qui repose sur AWT
mais certaines composantes ont été complètement
réécrites.
En réalité dans AWT pour chaque composante (exemple
un bouton) était associée une fenêtre.
Une simple application graphique se retrouvait avec une
multitude de fenêtres d'où la gourmandise en ressources
systèmes.
Les interfaces graphiques
Une interface graphique est formée d’une ou
plusieurs fenêtres qui contiennent divers
composants graphiques (widgets) tels que
Boutons
listes déroulantes
Menus
champ texte
etc.
Les interfaces graphiques sont souvent appelés
GUI d’après l’anglais Graphical User Interface
Programmation avec interfaces graphiques
L’utilisateur peut interagir à tout moment avec
plusieurs objets graphiques : cliquer sur un
bouton, faire un choix dans une liste déroulante
ou dans un menu, remplir un champ texte, etc…
Ces actions peuvent modifier totalement le
cheminement du programme, sans que l’ordre
d’exécution des instructions ne puisse être prévu
à l’écriture du code
Programmation événementielle
L’utilisation d’interfaces graphiques impose une façon
particulière de programmer
La programmation « conduite par les événements » est
du type suivant :
les actions de l’utilisateur engendrent des événements qui
sont mis dans une file d’attente
le programme récupère un à un ces événements et les traite
(A voir plus tard dans ce chapitre)
Les composants graphiques
Les composants Swing sont décrits comme légers.
Il existe des composants graphiques qui en contiennent
d'autres (et gèrent leur apparition, leur positionnement, ...)
=> Les conteneurs
d'autres qui n'en contiennent pas comme les boutons
poussoirs, les fenêtres textes de saisie, ... Ces derniers sont
parfois appelés les contrôles.
=> Les composants atomiques
1) Les conteneurs
Les conteneurs: JFrame
Une fenêtre de haut niveau, avec une bordure et un
titre.
Un JFrame possède les contrôles de fenêtre standard,
tels un menu système, des boutons pour réduire ou
agrandir la fenêtre ou la redimensionner. Il peut aussi
contenir une barre de menus.
Constructeur :
Constructeur sans argument : public JFrame () ;
Constructeur avec un argument (titre de la fenêtre) :
public JFrame (String name);
JFrame : Les méthodes
setTitle (String title) : Cette méthode modifie le titre de la fenêtre.
Ce titre va apparaître dans la barre de titre et également dans la
barre des tâches ;
setSize (int width, int height) : Cette méthode permet de modifier la
taille de la fenêtre ;
setLocationRelativeTo (Component c) : Cette méthode permet de
positionner la fenêtre par rapport à un composant. En indiquant un
composant null, elle va se placer automatiquement au milieu de
l'écran
setResizable (boolean resizable) : Cette méthode permet ou non le
redimensionnement de la fenêtre ;
setDefaultCloseOperation (int operation) : Cette méthode permet de
configurer l'action qui va être exécutée lors de la fermeture de la
fenêtre. On peut choisir de faire quitter le programme, de fermer la
fenêtre ou de la rendre invisible ;
show() ou bien setVisible (Boolean): Afficher la fenêtre.
JFrame : Les méthodes (Exemple)
import java.awt .*;
import javax.swing .*;
class Fenetre
{
public static void main(String [] args)
{
JFrame fenetre = new JFrame("Titre");
fenetre.pack();
fenetre.setVisible(true);
fenetre.setBounds(400,10,300,150);
//le coin supérieur gauche de la fenêtre
est place au pixel de coordonnées 400, 10
et ses dimensions seront de 300*150 pixels
}
}
JFrame : Les méthodes (Exemple)
JFrame créé
JPanel:
Un JPanel est un conteneur élémentaire destiné à contenir
d'autres composants. Il est muni d'un gestionnaire de placement
qui gère la stratégie de placement des différents composants
contenus dans le panneau.
Les méthodes:
Jpanel() : Création d'un panneau ;
void add (Component c) : Ajoute le composant c à la suite dans le
panneau ;
void add (Component c, int i) : Ajoute le composant c en position i
dans la liste des composants du panneau. L'indice du premier
composant est 0 ;
int getComponentCount () : Retourne le nombre de composants du
panneau ;
void remove (Component c) : Retire le composant c ;
void remove (int i) : Retire le composant de rang i ;
void removeAll () : Retire tous les composants.
JPanel : Exemple
import java . awt .* ;
import javax . swing .* ;
class PanelFrame extends Jframe
{
private JPanel panneau ;
public PanelFrame ()
super (" Une fenetre avec un panneau jaune ");
setSize(300,100);
panneau = new JPanel();
panneau.setBackground(Color.yellow) ;
JLabel jl = new JLabel ("BONJOUR !");
panneau . add(jl);
getContentPane().add( panneau ) ;//mettre à
jour IHM
}
/*+ code dans main pour créer et afficher la
JFrame */
}
2) Les composants atomiques
Les composants atomiques : Les boutons
Les boutons:
La classe JButton permet de définir des boutons sur lesquels on peut
cliquer.
Méthodes:
Jbutton(String) : Construction avec définition du texte contenu dans
le bouton ;
Jbutton(ImageIcon) : Construction avec une icône dans le bouton ;
Jbutton(String, ImageIcon) : Construction avec définition du texte et
d’une icône dans le bouton ;
void addActionListener(ActionListener) : Pour associer l’objet qui
traitera les clics sur le bouton.
Les boutons: Exemple
JButton start = new JButton (''Démarrer''); //
Création d'un bouton
JPanel p = new JPanel(); //création du conteneur
p.add (start); // Ajout du bouton au conteneur p
Les composants atomiques : Les cases à cocher
JCheckBox permet de définir des cases à cocher.
Méthodes:
JCheckBox (String) : Construction avec définition du texte contenu dans
la case à cocher ;
JCheckBox (String,boolean) : Construction avec en plus définition de
l’état initial de la case à cocher ;
boolean isSelected () : Retourne l’état de la case à cocher (cochée ou
non). Par défaut, une case à cocher est construite dans l’état non coché
(false) ;
void setSelected (boolean) : Définit l’état de la case à cocher (cochée
ou non) ;
void addActionListener(ActionListener) : Associer l’objet qui traitera les
actions sur la case à cocher.
//addActionListener(this): Ce code crée l'objet de la classe et appelle sa
méthode addActionListener(). Cette méthode permet de préciser la classe
qui va gérer l'événement utilisateur de type ActionListener du bouton.
Cette classe doit impérativement implémenter l'interface de type
EventListener .
Les composants atomiques : Les boutons radio
Le bouton radio de type JRadioButton permet à
l’utilisateur d’effectuer un choix de type oui/non.
JRadioButton fait partie d’un groupe de boutons dans
lequel une seule option peut être sélectionnée à la fois.
Un objet de type ButtonGroup sert uniquement à assurer
la désactivation automatique d’un bouton lorsqu’un
bouton du groupe est activé.
Un bouton radio qui n’est pas associé à un groupe,
exception faite de son aspect, se comporte exactement
comme une case à cocher.
Boutons radio: Exemple
import java . awt .*;
import javax . swing .*;
public class BoutonRadioFrame extends JFrame
{
private JRadioButton bRouge ;
private JRadioButton bVert ;
public BoutonRadioFrame ()
{
super (" Une fenetre avec des boutons radio ") ;
setBounds (10 ,40 ,300 ,200) ;
bRouge = new JRadioButton (" Rouge ") ;
bVert = new JRadioButton (" Vert ") ;
ButtonGroup groupe = new ButtonGroup () ;
groupe.add(bRouge); groupe.add(bVert ) ;
Container contenu = getContentPane () ;
contenu.setLayout(new FlowLayout()) ;
contenu.add(bRouge) ;
contenu.add(bVert) ;
}
// Le getContentPane() méthode récupère le contenu du volet couche de sorte que vous
pouvez ajouter un objet. Le volet de contenu est un objet créé par l'environnement
d'exécution Java.
// Les Layout managers sont des classes qui ont pour rôle de disposer les
composants de manière relative, sans utiliser de coordonnées.
Boutons radio: Exemple
public static void main ( String args [])
{
BoutonRadioFrame fen = new BoutonRadioFrame ();
fen. setVisible ( true );
fen. setBounds (10 , 200 , 300 , 150);
} }
Les composants atomiques : Les combobox
Un JComboBox est un composant permettant de faire un
seul choix parmi plusieurs propositions.
Méthodes :
JComboBox (Object[ ]) : Construction avec définition de
la liste. On peut utiliser un tableau de chaînes de
caractères (String) ou de toute autre classe d’objets :
void addItem (Object) : Ajoute une valeur possible de
choix :
int getSelectedIndex () : Retourne le numéro du choix
actuel :
void addActionListener(ActionListener) : Pour associer
l’objet qui traitera les choix faits
Les composants atomiques: Les zones de texte
Un JTextArea permet de définir des zones de texte sur
plusieurs lignes modifiables.
Méthodes :
JTextArea (String) : Crée une zone de texte avec un
contenu initial ;
JTextArea (String,int,int) : Crée une zone de texte avec
un contenu initial et précise le nombre de lignes et de
colonnes de la zone de texte ;
void append (String) : Ajoute la chaîne à la fin du texte
affiché
Les composants atomiques: Les labels
Un JLabel permet d’afficher du texte fixe ou une image. Il
peut contenir plusieurs lignes et il comprend les tag HTML. Le
JPasswordField permet de cacher ce qui est écrit.
Méthodes :
JLabel (String): Construit le titre avec son contenu ;
JLabel (Icon): Construit le titre avec une image comme contenu ;
void setText (String): Définit le texte ;
String getText (): Retourne le texte
void setIcon (ImageIcon): Définit l’image ;
Icon getIcon (): Retourne l’image sous forme d’un objet de classe
Icon.
Les labels: Exemple
import java.awt .*;
import javax.swing .*;
public class LabelFrame extends JFrame
{
public LabelFrame ()
{
super (" Une fenetre avec un Label ") ;
this.setBounds (100 , 200 , 300 , 100);
Container pane = this.getContentPane ();
pane.setLayout(new FlowLayout());
JLabel jl = new JLabel (" BONJOUR !");
jl.setFont(new Font("Arial",Font.BOLD|Font.ITALIC,
16));
jl.setForeground(Color.red);
pane.add(jl);
}
public static void main(String[] arg )
{
LabelFrame frame = new LabelFrame();
frame.setVisible(true);
} }
Les menus
Si on a une barre de menu JMenuBar, on ajoute des
JMenu dans la barre. Définir des menus → utiliser 3
classes JMenuBar, Jmenu, JmenuItem
JmenuBar : Barre des menus placée en haut de la fenêtre
d’une application. La méthode addSeparator() peut être
utilisée pour insérer un espace entre les composants de la
barre d’outils ;
Une barre de menu est composée de Jmenus. Un objet
JMenu possède un label, et quand on clique dessus, il peut
montrer un menu déroulant ;
Un item d’un objet JMenu peuvent être un objet de type
JmenuItem, JCheckBoxMenuItem ou JradioButtonMenuItem ;
Un objet JMenuItem est un simple élément de menu avec un
label. Il peut avoir une icône en plus de son label.
Les menus: Exemple
import java . awt .*;
import javax . swing .*;
public class FrameMenu extends JFrame
{
Container pane = this . getContentPane ();
public FrameMenu ()
{
setTitle (" FrameMenu ");
JMenuBar jmb = new JMenuBar ();
this . setJMenuBar ( jmb );
JMenu menuDefinir = new JMenu (" Definir ");
jmb. add( menuDefinir );
Les menus: Exemple
menuDefinir . add( new JMenuItem ("le nom " ));
menuDefinir . add( new JMenuItem ("le prenom " ));
JMenu menuAfficher = new JMenu (" Afficher ");
jmb. add( menuAfficher );
}
/* + methode main */
}
Les boites de message
Une boîte de message fournit à l'utilisateur un message
qui reste affiché tant que l'utilisateur n'agit pas sur le
bouton OK. Elle est construite à l'aide de la méthode de
classe showMessageDialog de la classe JOptionPane.
Les boites de dialogue
import javax.swing.* ;
class MaFenetre extends JFrame
{
MaFenetre ()
{
setTitle ("Essai message") ;
setSize (400, 150) ;
}}
public class Mess1
{
public static void main (String args[])
{
MaFenetre fen = new MaFenetre() ;
fen.setVisible(true) ;
JOptionPane.showMessageDialog(fen, "Bonjour");
//le premier argument de la méthode showMessageDialog correspond à la fenêtre
parent
//de la boîte de message, c'est-à-dire la fenêtre dans laquelle la boîte de message
va //s'afficher. Cet argument eut prendre la valeur null.
}}
Les boites de dialogue
Les boites de dialogue
Dans l'exemple précédent, nous n'avons défini que le contenu du
message.
Il existe une variante de la méthode howMessageDialog qui permet
aussi de choisir le titre de la boîte et le type d'icône parmi la liste
suivante (les paramètres sont des constantes entières de la classe
JoptionPane).
Les boites de confirmation
Une boîte de confirmation offre à l'utilisateur un choix de
type oui/non.
Elle est construite à l'aide de la méthode de classe
showConfirmDialog de la classe JOptionPane.
import javax.swing.* ;
public class Input1
{
public static void main (String args[])
{
JOptionPane.showConfirmDialog(null, "Voulez-
vous continuer ?") ;
} }
Les boites de saisie
Une boîte de saisie permet à l'utilisateur de fournir une
information sous la forme d'une chaîne de caractères. Elle est
construite à l'aide de la méthode de classe showInputDialog
de la classe JOptionPane.
Exemple:
import javax.swing.* ;
public class Input1
{
public static void main (String args[])
{
JOptionPane.showInputDialog (null, "donnez un
texte");
} }
3) Les gestionnaires de mise en page
Les gestionnaires de mise en page
Pour placer des composants dans un container, Java
propose une technique de Layout.
Un layout est une entité Java qui place les composants
les uns par rapport aux autres.
Le layout s’occupe aussi de réorganiser les composants
lorsque la taille du container varie.
Il y a plusieurs layout: BorderLayout, BoxLayout,
CardLayout, FlowLayout, GridLayout, GridBagLayout.
Un layout n’est pas contenu dans un container, il gère le
positionnement.
BorderLayout
Le BorderLayout sépare un container en cinq zones :
Nord, Sud, Est, Ouest et Centre.
Lorsque l’on agrandit le container, le centre s’agrandit.
Les autres zones prennent uniquement l’espace qui leur
est nécessaire.
Les composants y sont ajoutés par la méthode
add(Component, int) dont le second paramètre indique
dans quelle zone doit être placé le composant.
Ce paramètre peut prendre les valeurs :
BorderLayout.NORTH, BorderLayout.SOUTH,
BorderLayout.EAST, BorderLayout.WEST ou
BorderLayout.CENTER.
BorderLayout: Exemple
import java . awt .* ;
import javax . swing .* ;
class FrameDemo5 extends JFrame
{
public FrameDemo5 ()
{
super (" Une fenetre ") ;
setSize (400 , 200) ;
Container contenu = this . getContentPane () ;
contenu . setLayout ( new BorderLayout ()) ;
contenu . add ( new JButton (" Bouton UN")) ;
// bouton placé au centre par défaut
contenu . add ( new JButton (" Bouton DEUX "), BorderLayout . NORTH ) ;
contenu . add ( new JButton (" Bouton TROIS "), BorderLayout . SOUTH ) ;
contenu . add ( new JButton (" Bouton QUATRE "),BorderLayout . WEST ) ;
contenu . add ( new JButton (" Bouton CINQ "), BorderLayout . EAST ) ;
}
public static void main ( String args [ ])
{
JFrame fen = new FrameDemo5 () ;
fen. setVisible ( true ) ;
}}
FlowLayout
Un FlowLayout permet de ranger les composants dans
une ligne.
Si l’espace est trop petit, une autre ligne est créée.
Le FlowLayout est le layout par défaut des JPanel, son
constructeur accepte trois paramètres selon le modèle
suivant : FlowLayout (int,int,int) :
Le premier paramètre indique comment seront alignés les
composants, il peut prendre les valeurs suivantes :
FlowLayout.CENTER, FlowLayout.LEFT ou FlowLayout.RIGHT ;
Le deuxième paramètre donne l’espacement horizontal
entre composants (en pixels);
Le dernier paramètre donne l’espacement vertical entre
composants (en pixels).
FlowLayout: Exemple
Container contenu=this.getContentPane();
contenu.setLayout(new FlowLayout());
contenu.add (new JButton("Button 1"));
contenu.add(new JButton("2"));
contenu.add(new JButton ("Button 3"));
contenu.add(new JButton("Long-Named Button 4"));
contenu.add(new JButton(" Button 5"));
GridLayout
Un GridLayout permet de positionner les composants sur une
grille. Son constructeur GridLayout (int,int,int,int) accepte
quatre paramètres :
Le premier paramètre est le nombre de lignes du tableau
Le deuxième paramètre est le nombre de colonnes du tableau ;
Le troisième paramètre donne l’espacement horizontal entre
composants (en pixel) ;
Le dernier paramètre donne l’espacement vertical entre
composants (en pixels).
Toutes les cases du tableau ont la même taille (celle
déterminée par le composant le plus grand).
Les composants seront ajoutés par la suite à l’aide de la
méthode add (Component) qui remplira le tableau ligne par
ligne.
GridLayout: Exemple
Container contenu = this.getContentPane();
contenu.setLayout(new GridLayout(0,2));
contenu.add(new JButton ("Button 1"));
contenu.add(new JButton ("2"));
contenu.add(new JButton ("Button 3" ));
contenu.add(new JButton ("Long - Named Button 4"));
contenu.add(new JButton("Button 5"));
