Badr Benmammar bbm@badr-benmammar.com Formation Développeur Java Applet et interfaces graphiques avec AWT Badr Benmammar bbm@badr-benmammar.com
Plan Applet Applet Interactive : Écouteurs Interfaces graphiques avec AWT Composants simples Button, Label, TextField, Checkbox, List, … Composants conteneurs Frame et Panel Gestion des évènements BorderLayout FlowLayout GridLayout
Applet : dessiner en JAVA import java.awt.Graphics ; import java.applet.Applet; public class Prog11 extends Applet { public void paint (Graphics g) { g.drawLine (10, 30, 200, 30); g.drawRect (20, 40, 100, 50); g.drawOval (140, 40, 50, 50); g.drawString ("bonjour !", 10, 120); } <html> <head><title>applet Prog11</title> </head> <body> <applet code="Prog11.class" width=400 height=300> </applet> </body> </html> Les lignes de la classe : Importer les packages graphique et applet. Notre classe hérite de la classe Applet : il suffit de re-définir la méthode paint en utilisant des méthodes de dessin de la classe Graphics. drawLine = dessiner une ligne du point (10,30) au point (200,30). Les lignes du fichier html : Une applet (une fois compilée) doit être appelée dans un fichier html. Puis, pour être exécutée, le fichier html sera visualisé dans un navigateur ou dans l'outil AppletViewer. 400 et 300 seront les dimensions en pixel (respectivement largeur, hauteur) de la zone graphique de l'applet. Les points (pixel) composant la fenêtre sont repérés relativement au coin gauche haut de coordonnées (0,0). Le point de coordonnées (x,y) est placé à x points du bord gauche et y points du haut. Une applet est un petit programme Java destiné à être téléchargé et exécuté par un navigateur internet.
Applet : dessiner en JAVA Exécution: appletviewer dessin.html
Applet : dessiner en JAVA import java.awt.Graphics; import java.awt.Color; import java.applet.Applet; public class Prog12 extends Applet { public void init( ) { setSize(220,120); setForeground(Color.red); setBackground(Color.white); } public void paint(Graphics g) { g.drawLine(10, 30, 200, 30); g.fillRect(20, 40, 100, 50); g.setColor(Color.blue); g.drawOval(140, 40, 50, 50); g.drawString("texte dessine", 10, 60);
Applet : dessiner en JAVA import java.awt.Graphics; import java.awt.Color; import java.applet.Applet; public class Prog12 extends Applet { public void init( ) { setSize(220,120); setForeground(Color.red); setBackground(Color.white); } public void paint(Graphics g) { g.drawLine(10, 30, 200, 30); g.fillRect(20, 40, 100, 50); g.setColor(Color.blue); g.drawOval(140, 40, 50, 50); g.drawString("texte dessine", 10, 60); La méthode paint reçoit le contexte graphique par défaut. La méthode init est appelée une seule fois à la création de l'applet. Initialisation de l'applet : modification de sa taille, et des couleurs de fond et de dessin.
Applet : dessiner en JAVA Une Applet ne possède pas de méthode main() mais une ou plusieures méthodes parmi les méthodes init(), start(), stop(), destroy() ou paint() héritées de la super-classe Applet : init() est lancée par le Navigateur dès que le chargement de l'applet est terminé. start() est lancée après init() et à chaque re-chargement de la page html. paint() est lancée à chaque fois que l'applet est rendue visible; cette méthode peut récupérer le paramètre Graphics utile pour dessiner. stop() est lancée quand le navigateur change de page ou quand l'applet se termine ou avant destroy(). destroy() est lancée à la fermeture du navigateur.
Dessiner des Rectangles import java.awt.Graphics; public class Rectangle5 { double x, y, largeur, hauteur; Rectangle5 (double valX, double valY, double valL, double valH) { x = valX; y = valY; largeur = valL; hauteur = valH; } void dessiner(Graphics g) { g.drawRect((int)x, (int)y, (int)largeur, (int)hauteur); import java.awt.Graphics; import java.applet.Applet; import java.awt.Color; public class Prog31 extends Applet { public void init( ) { setSize(220,180); setForeground(Color.red); setBackground(Color.white); } public void paint (Graphics g) { Rectangle5 r1, r2,r3; r1 = new Rectangle5(60,40,45,45); r2 = new Rectangle5(20,90,60,40); r3 = new Rectangle5(85,90,60,40); r1.dessiner(g); r2.dessiner(g); r3.dessiner(g);
Affichage de treillis: croisement de lignes import java.awt.Graphics; import java.applet.Applet; public class Prog13 extends Applet { public void paint (Graphics g) { int x, y, t, i; x=30; y=40; t=140; for (i=0; i<=t; i+=5) g.drawLine (x, y+i, x+i, y+t); }
Applet Interactive public void paint (Graphics g) { if (affiche) import java.awt.*; public class Rectangle6 { double x, y, largeur, hauteur; Color couleur; Rectangle6 (double valX, double valY, double valL, double valH, Color c) { x = valX; y = valY; largeur = valL; hauteur = valH; couleur = c; } void setPosition (double valX, double valY){ x = valX; y = valY; boolean estDans (double valX, double valY){ return ((x<=valX)&&(x+largeur>=valX) &&(y<=valY))&&(y+hauteur>=valY); } void dessiner(Graphics g) { g.setColor (couleur); g.fillRect ((int)x, (int)y, (int)largeur, (int)hauteur); public void paint (Graphics g) { if (affiche) rectRouge.dessiner (g); else rectBleu.dessiner (g); } public void mouseClicked (MouseEvent e) { affiche = ! affiche; repaint(); public void mouseEntered(MouseEvent e) {} public void mouseExited(MouseEvent e) {} public void mousePressed(MouseEvent e) {} public void mouseReleased(MouseEvent e) {} import java.awt.*; import java.awt.event.*; import java.applet.Applet; public class Prog67 extends Applet implements MouseListener { Rectangle6 rectRouge, rectBleu; boolean affiche; public void init() { addMouseListener (this); affiche = true; rectRouge =new Rectangle6 (30,30,50,80,Color.red); rectBleu =new Rectangle6 (30,30,50,80,Color.blue); } <html> <body> <applet code="Prog67.class" width=450 height=150> </applet> </body> </html> Un clic de souris pour faire apparaître le rectangle rouge, puis un autre pour faire apparaître le rectangle bleu. Le clic (enfoncement puis relâchement) d'un bouton de la souris provoque un événement e de type MouseEvent envoyé comme message à l'applet et provoquant l'exécution de la méthode mouseClicked.
Interface MouseListener MouseListener définit l'écouteur d'événement Souris : press, release, click, enter, exit. addMouseListener installe un écouteur MouseListener sur un composant. Les méthodes à (toutes) définir sont : public void mousePressed(MouseEvent e) définit le traitement quand survient l'événement qui indique qu'un bouton de la souris est pressé dans l'aire du composant. public void mouseReleased(MouseEvent e) ...événement bouton de souris "relaché" dans l'aire du composant. public void mouseClicked(MouseEvent e) ...événement bouton de souris "pressé-relaché" public void mouseEntered(MouseEvent e) ... événement souris "entre" dans l'aire du composant. public void mouseExited(MouseEvent e) ... événement souris "sort" de l'aire du composant. mouseEvent.getX() donne la coordonnée x de la souris au moment de l'événement. mouseEvent.getY() donne la coordonnée y.
Lignes de la classe L'applet (dans sa zone/fenêtre graphique) est le siège d'événement de la souris. Jusqu'ici, ces événements étaient ignorés. Maintenant, on ajoute un écouteur (un gestionnaire) de ces événements : this, c'est à dire l'applet elle-même. Donc, elle traitera elle-même les événements souris dont elle est le siège. L'applet aura la capacité de traiter les événement de la souris puisqu'elle implémente MouseListener : elle est à l'écoute des événements de la souris. Définition de la méthode mouseClicked qui réagit au clic de la souris. Pour les autres traitements :mousePressed, mouseReleased, mouseEntered et mouseExited, le traitement est vide. repaint rafraichie l'applet en appelant paint.
Placer un dessin à l'endroit cliqué import java.awt.*; import java.awt.event.*; import java.applet.Applet; public class Prog36 extends Applet implements MouseListener { Rectangle6 rect; public void init() { rect = new Rectangle6(30,30,50,80, Color.yellow); addMouseListener(this); } public void paint(Graphics g) { rect.dessiner(g); public void mouseClicked(MouseEvent e) { int x,y; x = e.getX(); y = e.getY(); rect.setPosition(x,y); repaint(); } public void mouseEntered(MouseEvent e) {} public void mouseExited(MouseEvent e) {} public void mousePressed(MouseEvent e) {} public void mouseReleased(MouseEvent e) {}
Evénements et leurs méthodes associées import java.awt.*; import java.awt.event.*; import java.applet.Applet; public class Prog37 extends Applet implements MouseListener, KeyListener, MouseMotionListener { String message = "aucun"; public void init() { addMouseListener (this); addMouseMotionListener (this); addKeyListener (this); } public void paint (Graphics g) { g.drawString(message, 20, 50); } public void mouseClicked(MouseEvent e) { message = "mouseClicked"; repaint(); } public void mouseEntered(MouseEvent e) { message = "mouseEntered"; public void mouseExited(MouseEvent e) { message = "mouseExited"; public void mousePressed(MouseEvent e) { message = "mousePressed"; repaint(); } public void mouseReleased(MouseEvent e) { message = "mouseReleased"; public void mouseDragged(MouseEvent e) { message = "mouseDragged"; public void mouseMoved(MouseEvent e) { message = "mouseMoved"; public void keyTyped(KeyEvent e) { public void keyPressed(KeyEvent e) { public void keyReleased(KeyEvent e) { }
Interfaces souris et clavier Attention ! l'Applet ne reçoit pas les événements provenant du clavier lorsqu'elle est lancée par Appletviewer. L'interface MouseListener se compose des méthodes mouseClicked, mousePressed, mouseReleased, mouseEntered et mouseExited. Les méthodes mouseClicked, mousePressed, mouseReleased sont appelées lorsque respectivement la souris est cliquée, un de ses boutons pressé, relâché. Les méthodes mouseEntered et mouseExited sont appelées lorsque respectivement la souris entre ou sort de la "fenêtre" de l'applet. Leur paramètre de type MouseEvent permet de récupérer les coordonnées int de la souris : e.getX() e.getY().
Interfaces souris et clavier L'interface MouseMotionListener se compose des méthodes mouseDragged et mouseMoved. Les méthodes mouseDragged et mouseMoved sont appelées lorsque la souris est bougé et que respectivement un des boutons de la souris est enfoncé ou non. Leur paramètre de type MouseEvent permet de récupérer les coordonnées int de la souris : e.getX() e.getY(). L'interface KeyListener se compose des méthodes keyPressed, keyReleased, keyTyped. Les méthodes keyPressed, keyReleased, keyTyped sont appelées lorsque respectivement une touche au clavier est pressée, relâchée, une touche caractère est tapée.
Plusieurs objets à bouger à la souris import java.awt.*; import java.awt.event.*; import java.applet.Applet; public class Prog38 extends Applet implements MouseListener, MouseMotionListener { Rectangle6 rect1, rect2; boolean clicRect1, clicRect2; public void init() { rect1 = new Rectangle6(30,30,50,80,Color.gray); rect2 = new Rectangle6(100,60,70,30,Color.green); clicRect1 = false; clicRect2 = false; addMouseListener (this); addMouseMotionListener (this); } public void paint (Graphics g) { rect1.dessiner(g); rect2.dessiner(g); public void mousePressed (MouseEvent e){ if (rect1.estDans(e.getX(),e.getY())) clicRect1=true; if (rect2.estDans(e.getX(),e.getY())) clicRect2=true; } public void mouseDragged (MouseEvent e){ if (clicRect1) { rect1.setPosition (e.getX(),e.getY()); repaint(); } if (clicRect2) { rect2.setPosition(e.getX(),e.getY()); repaint(); } } public void mouseReleased (MouseEvent e){ if (clicRect1) clicRect1=false; if (clicRect2) clicRect2=false; public void mouseEntered(MouseEvent e) {} public void mouseExited(MouseEvent e) {} public void mouseClicked(MouseEvent e) {} public void mouseMoved(MouseEvent e) {}
Dessin à la souris import java.awt.*; import java.awt.event.*; import java.applet.Applet; public class Prog39 extends Applet implements MouseListener, MouseMotionListener { int x0, y0; Graphics g; public void init() { x0=0; y0=0; g = getGraphics(); addMouseListener(this); addMouseMotionListener(this); } public void mousePressed (MouseEvent e){ int x,y; x = e.getX(); y = e.getY(); x0=x; y0=y; } public void mouseDragged (MouseEvent e){ int x,y; x = e.getX(); y = e.getY(); g.drawLine (x0, y0, x, y); x0=x; y0=y; } public void mouseEntered(MouseEvent e) {} public void mouseExited(MouseEvent e) {} public void mouseClicked(MouseEvent e) {} public void mouseReleased(MouseEvent e) {} public void mouseMoved(MouseEvent e) {}
Interfaces graphiques avec AWT Abstract Window Toolkit (AWT) est une bibliothèque graphique pour Java, faisant partie de JFC (Java Foundation Classes). Cette bibliothèque a été introduite dès les premières versions de Java mais depuis Java 2, la bibliothèque de gestion de fenêtre officielle est Swing. Toutefois, AWT sert encore de fondement à Swing, dans la mesure où de nombreuses classes Swing héritent de classes AWT. AWT emploie les composants natifs de la plateforme, alors que Swing utilise des composants en pur Java. AWT n'est pas compatible avec Swing.
Composants simples import java.awt.List; import java.awt.Button; import java.awt.Label; import java.awt.TextField; import java.awt.Checkbox; import java.applet.Applet; public class Prog44 extends Applet { public void init ( ) { Button monBouton = new Button ("bouton"); add (monBouton); Label monLabel = new Label("label"); add(monLabel); List maListe = new List(2); maListe.add("bleu"); maListe.add("rouge"); maListe.add("vert"); add(maListe); TextField champTexte = new TextField("du texte",15); add(champTexte); Checkbox caseACocher = new Checkbox ("ok ?",true); add(caseACocher); } Un bouton Button est un composant graphique. La méthode add() de Applet ajoute un composant graphique dans l'espace de l'applet. Un "label" Label est un texte constant affiché dans notre applet. Une liste à choisir List permet de choisir une valeur parmi plusieurs, ici, seuls 2 sont visibles à la fois mais un curseur permet de faire défiler toute la liste. Un champ texte TextField est une zone éditable simple d'une ligne. Une case à cocher Checkbox prend une valeur binaire selon qu'il est coché (true) ou non (false).
Composants simples import java.awt.List; import java.awt.TextArea; import java.awt.Checkbox; import java.awt.CheckboxGroup; import java.applet.Applet; public class Prog45 extends Applet { public void init() { List maListe = new List (3,true); maListe.add("bleu"); maListe.add("rouge"); maListe.add("vert"); maListe.add("noir"); add(maListe); maListe.select(0); maListe.select(2); TextArea zoneTexte = new TextArea(10, 20); add(zoneTexte); zoneTexte.setText("une premiere ligne \n"); zoneTexte.append("une seconde ligne"); CheckboxGroup choixCouleur = new CheckboxGroup(); Checkbox caseRouge = new Checkbox("rouge",false,choixCouleur); add(caseRouge); Checkbox caseBleu = new Checkbox("bleu",false,choixCouleur); add(caseBleu); Checkbox caseVert = new Checkbox("vert",false,choixCouleur); add(caseVert); choixCouleur.setSelectedCheckbox(caseBleu); }
Composants simples Une liste à choisir peut être à sélection unique ou multiple : Unique : au plus un élément de la liste peut être sélectionné. Ici, elle est multiple (true). La méthode select() permet de faire une sélection, les choix sont indicés à partir de 0. Un "éditeur" TextArea est une zone de texte éditable sur plusieurs lignes, avec souvent des barres de défilement : Ici, il fait 10 lignes et 20 colonnes. La méthode setText modifie son contenu texte intégralement. La méthode append ajoute du texte. Les cases à cocher Checkbox sont, sans indication, indépendantes. Un CheckboxGroup permet d'en regrouper pour que leur sélection soit mutuellement exclusive : une, au plus, est cochée ! La méthode setselectedCheckbox permet d'en cocher une dans le groupe.
Composants simples Button : un bouton à cliquer. Constructeurs : Button() crée un bouton sans texte. Button(String texte) crée un bouton avec texte centré. Quelques méthodes : setLabel(String texte) spécifie le texte du bouton. getLabel() retourne le texte du bouton. Label : étiquette : affiche un petit texte/message. Label() crée une étiquette sans texte. Label(String texte) crée une étiquette avec texte aligné à gauche. Label(String texte, int aligne) crée une étiquette avec texte aligné selon aligne : Label.LEFT, Label.CENTER, Label.RIGHT. setText(String texte) spécifie le texte. getText() retourne le texte de l'étiquette. setAlignment(int aligne) spécifie l'alignement. getAlignment().
Composants simples TextField : champ texte d'une ligne pour saisir et/ou afficher du texte modifiable Constructeurs : TextField() crée un champ sans texte. TextField(int nombre) crée un champ sans texte d'une largeur de nombre caractères. TextField(String texte) crée un champ avec texte. TextField(String texte, int nombre) crée un champ avec texte et d'une largeur de nombre caractères. Quelques méthodes : setText(String texte) spécifie le texte du champ. getText() retourne le texte contenu dans le champ. getColumns() retourne la largeur du champ en nombre caractères. setColumns() définit la largeur du champ en nombre caractères. setEditable(boolean modifiable) spécifie si le texte du champ est modifiable. isEditable() retourne un boolean qui indique si le texte du champ est modifiable. setEchoChar(char masque) spécifie le caractère de masquage de la saisie (pour les passwords). echoCharSet() retourne un boolean qui indique si le masquage est en vigueur. getEchoChar() retourne le caractère de masquage.
Composants simples TextAera : éditeur de texte pour saisir et/ou afficher du texte modifiable sur plusieures lignes, muni de barres de défilement de comportements prédéfinies : sélection de texte à la souris, raccourci clavier copier/coller, ..., Constructeurs : TextAera() crée un éditeur sans texte. TextAera(int ligne, int largeur) crée un éditeur sans texte d'une largeur en nombre de caractères et d'un nombre de lignes spécifiés. TextAera(String texte) crée un éditeur avec texte. TextAera(String texte, int ligne, int largeur) crée un éditeur avec texte et d'une largeur et d'un nombre de lignes spécifiés. Quelques méthodes : insertText(String texte, int position) insère le texte à la position indiquée. replaceText(String texte, int départ, int fin) remplace les caractères entre les positions indiquées par le texte spécifié. getText() ... setText() isEditable() setEditable()
Composants simples Checkbox et CheckboxGroup : cases à cocher et boutons radios, peuvent être plusieurs (indépendantes ou exclusives ) et permettent le déclanchement d'action. Les cases à cocher sont indépendantes, les boutons radios sont en exclusion mutuelle, c'est à dire qu'un seul au plus peut être coché. Constructeurs : Checkbox(String texte) crée une case à cocher (initialisée à non cochée) avec texte associé. Checkbox(String texte, boolean cochée) crée une case à cocher avec texte associé, cochée ou non selon la valeur booléenne. CheckboxGroup() crée un groupe de boutons radios. Checkbox(String texte, boolean cochée, CheckboxGroup groupe) crée une bouton radio avec texte associé, cochée ou non selon la valeur booléenne, faisant partie du groupe indiqué. Quelques méthodes de Checkbox : setLabel(String texte) spécifie le texte de la case à cocher (ou bouton radio). getLabel() retourne le texte de la case à cocher. getState() retourne true si la case est cochée. setState(boolean cochée) coche ou non la case selon la valeur booléenne. Quelques méthodes de CheckboxGroup : setSelectedCheckbox(Checkbox unBoutonRadio) permet d'en cocher un dans le groupe.
Composants simples List : une liste à choisir peut être à sélection unique ou multiple : Constructeurs : List() crée une liste de choix. List(int nombre) crée une liste de choix avec nombre lignes visible. List(int nombre, boolean choixMultiple) crée une liste de choix avec nombre lignes visible et à sélection unique si choixMultiple est false sinon à choix multiple. Quelques méthodes : add(String choix) ajoute un choix en fin de liste. isMultipleMode() true si la liste est en choix multiple. getSelectedIndex() renvoie l'index de la sélection dans la liste (numérotée à partir de 0), ou -1 s'il n'y en a pas ou s'il y en a plus d'une. getSelectedIndexes() renvoie un tableau d'entiers : les index des sélections dans la liste. select(int indice) sélectionne un choix dans la liste à l'indice indiqué.
Composants conteneurs import java.awt.Label; import java.awt.Frame; import java.awt.Button; import java.awt.Checkbox; public class Prog58 extends Frame { public Prog58 ( ) { add ("South", new Button ("bouton1")); add ("East", new Label ("label1")); add ("Center", new Button ("bouton2")); add ("West", new Checkbox ("case à cocher", false)); setVisible (true); pack (); } public static void main (String args[]) { new Prog58 ( );
Frame Frame est une fenêtre de haut niveau (top level): une fenêtre d'application, elle peut contenir des composants graphique : la méthode add permet de les ajouter, elle est donc aussi un container. Les Applets que nous avons souvent utilisés sont des containers mais ne sont pas des fenêtres top level, la fenêtre top level d'une applet est celle du navigateur qui la visualise ou celle de Appletviewer. L'application crée dans sa méthode main une instance objet graphique "de type Frame". Les frames sont gérées par défaut par le gestionnaire BorderLayout : qui divise un composant container en 5 zones: North, East, South, West, Center. La méthode add doit être utilisé ainsi : add ("zone", composant). pack() re-dimensionne la frame et ses composants à la taille "idéale". Pour terminer l'application, la "croix " ou bouton de fermeture ne marche pas car nous n'avons pas mis en place le code nécessaire. Pour l'instant, CTRL-C dans la console permet de terminer l’application.
Frame : gestionnaire FlowLayout import java.awt.Label; import java.awt.Frame; import java.awt.Button; import java.awt.Checkbox; import java.awt.FlowLayout; public class Prog59 extends Frame { public Prog59() { setLayout (new FlowLayout (FlowLayout.LEFT,5,15)); add (new Button ("bouton1")); add (new Label ("label1")); add (new Button ("bouton2")); add (new Checkbox ("case à cocher", false)); setVisible (true); pack(); } public static void main(String args[]) { new Prog59(); Frame est le container ici et les boutons, label, case à cocher sont les composants contenus dedans. FlowLayout est un des gestionnaires de placement ou encore un geometry manager : ici il organisera les composants contenus dans la frame selon une "politique" à gauche d'abord et avec un espace horizontale de 5 pixels entre les composants contenus et verticalement de 15 pixels. setLayout détermine le nouveau geometry manager du composant container Frame.
Frame : gestionnaire GridLayout import java.awt.Label; import java.awt.Frame; import java.awt.Button; import java.awt.Checkbox; import java.awt.GridLayout; public class Prog69 extends Frame { public Prog69() { setLayout (new GridLayout (2,2)); add (new Button ("bouton1")); add (new Label ("label1")); add (new Button ("bouton2")); add (new Checkbox ("case à cocher", false)); setSize(200,40); setVisible(true); } public static void main(String args[]) { new Prog69(); Le geometry manager GridLayout a une organisation en grille : ici, 2 lignes et 2 colonnes. Les composants contenus sont introduits au fer et à mesure par add en (1,1) puis en (1,2) puis en (2,1) puis en (2,2). setSize() redimensionne la Frame à la dimension indiquée.
Panel import java.awt.Label; import java.awt.Frame; import java.awt.Button; import java.awt.Checkbox; import java.awt.GridLayout; import java.awt.Panel; public class Prog70 extends Frame { public Prog70() { setLayout (new GridLayout (3,1)); add (new Button("bouton1")); Panel boite=new Panel (); boite.add (new Label ("label2")); boite.add (new Button ("bouton2")); add (boite); add(new Checkbox("case à cocher", true)); setVisible(true); pack(); } public static void main(String args[]) { new Prog70(); Panel est juste un container : dans ce container, nous plaçons le label2 et le bouton2. Le geometry manager de Panel est par défaut le FlowLayout manager. Ce panel est ajouté dans la Frame. Pour la frame, notre Panel est un composant contenu.
Création de nouveaux composants à partir de Panel import java.awt.Button; import java.awt.GridLayout; import java.awt.Panel; import java.applet.Applet; class PanneauClavier extends Panel { PanneauClavier ( ) { setLayout (new GridLayout (4,3)); for (int num=1; num <= 9 ; num++) add (new Button(Integer.toString(num))); add(new Button("*")); add(new Button("0")); add(new Button("# ")); } public class demo extends Applet { public void init() { add (new PanneauClavier ( ));
Même chose avec Frame import java.awt.Button; import java.awt.GridLayout; import java.awt.Frame; public class Maframe extends Frame { public Maframe() { setLayout (new GridLayout (4,3)); for (int num=1; num <= 9 ; num++) add(new Button(Integer.toString(num))); add(new Button("*")); add(new Button("0")); add(new Button("# ")); setVisible(true); pack(); } public static void main(String args[]) { new Maframe();
Charger une image dans une applet import java.awt.Dimension; import java.awt.Graphics; import java.awt.Image; import java.awt.MediaTracker; import java.awt.Panel; import java.awt.Toolkit; import java.applet.Applet; class LIVRE extends Panel { private Image image; public LIVRE(String filename) { image = Toolkit.getDefaultToolkit().getImage("livre.gif"); try { MediaTracker mt = new MediaTracker(this); mt.addImage(image, 0); mt.waitForAll(); } catch (Exception e) { e.printStackTrace(); } this.setPreferredSize(new Dimension (image.getWidth(this),image.getHeight(this))); public void paint(Graphics g) { g.drawImage(image, 0, 0, null); public class AfficheImage extends Applet { public void init() { add (new LIVRE ("LIVRE")); Remarque : Le chargement avec Toolkit se fait de façon asynchrone. Il faut alors utiliser une instance de la classe MediaTracker pour patienter le temps de chargement de l'image et ainsi pouvoir déterminer sa taille pour la reporter sur la taille du composant.
Charger une image dans une applet
Ajouter une applet dans une frame import java.awt.Graphics; import java.applet.Applet; public class dessin extends Applet { public void paint (Graphics g) { g.drawLine (10, 30, 200, 30); g.drawRect (20, 40, 100, 50); g.drawOval (140, 40, 50, 50); g.drawString ("bonjour !", 10, 120); } import java.awt.Frame; public class Maframe2 extends Frame { public Maframe2() { add ("Center", new dessin()); setVisible(true); setSize(300,200) ; public static void main(String args[]) { new Maframe2();
Classe Component La plupart des Classes de l'AWT hérite de la classe abstraite Component (composant en français). Quelques méthodes : paint(Graphics g) est la méthode appelée à chaque fois que le contenu du composant doit être redessiné (la 1ére fois, quand il fut masqué puis démasqué, ...); elle est à redéfinir en spécifiant tout ce qui doit être dessiné. repaint() provoque un appel à paint(), donc redessine le contenu du composant. getGraphics() renvoie le contexte graphique de type Graphics du composant : c'est à dire la trousse à dessiner actuelle. setVisible(boolean visible) affiche ou masque le composant. setEnabled(boolean actif) active ou non le composant, c'est à dire le rend sensible aux événements.
Classe Component getSize() donne la dimension actuelle du composant, retourne le type Dimension qui est utilisable ainsi : getSize().height et getSize().width. getPreferedSize() donne la taille "idéale" du composant, retourne le type Dimension. setSize(Dimension d) redimensionne le composant à la dimension indiquée. setSize(int largeur, int hauteur) redimensionne le composant. move(int coordX, int coordY) déplace le composant au point indiqué (coin haut et gauche). setForeground(Color couleur) définit la couleur d'avant-plan (de dessin) du composant. setBackground(Color couleur) définit la couleur de fond. setCursor(Cursor curseur) définit la couleur du curseur.
Classe Container Classe abstraite pour les composants qui contiennent et gèrent d'autres composants (conteneur en français). Chaque container possède un gestionnaire de placement par défaut, layout ou "geometry manager", qui range les composants graphiques fils dans le container. Il est possible de ne pas les utiliser en plaçant chaque composant à l'aide de la méthode setLocation(int coordX, coordY). Quelques méthodes : setLayout (LayoutManager manager) spécifie le geometry manager qui rangera (arrangera) les composants contenus. add (composant) ajoute un composant dans le container.
Héritage entre composants Object Component Window Panal Frame Classes abstraites Graphics Button Canvas Checkbox Container Label List Fenêtre ordinaire Fenêtre top-level Applet
Frame Frame : fenêtre top-level conteneur d'une application avec barre de titre et des boutons de fermeture. Le layout par défaut est BorderLayout Constructeurs : Frame() crée une fenêtre sans titre. Frame(String titre) crée une fenêtre avec titre. Quelques méthodes : pack() redimensionne la frame et ses composants à leur preferredSize (la taille juste nécessaire). setTitle(String titre) spécifie le titre. setMenuBar(MenuBar) applique une barre de menu en haut du cadre. setResizable(boolean) détermine si le cadre peut être redimensionné par l'utilisateur.
Panel Panel : composant conteneur d'autres composants. La classe Applet hérite de Panel. Le layout par défaut est FlowLayout. Constructeurs : Panel() crée un Panel. Panel(LayoutManager manager) crée un Panel avec le geometry manager spécifié.
Geometry manager Plusieurs gestionnaires de placement, geometry manager, qui rangent des composants graphiques dans un container. Il est possible de ne pas les utiliser en placant chaque composant dans un Panel à l'aide de la méthode setLocation (int coordX, coordY) FlowLayout : range de gauche à droite et de haut en bas. Constructeurs : FlowLayout() range les composants en les centrant avec un "vspacing et hspacing" (espace vertival, respectivement horizontal) de 5 pixels. FlowLayout(int aligne) range les composants en les alignant selon aligne : FlowLayout.LEFT, FlowLayout.CENTER, FlowLayout.RIGHT avec un vspacing et hspacing de 5 pixels. FlowLayout(int aligne, int hspacing, int vspacing) range selon l'alignement et le vspacing et le hspacing spécifiés.
Geometry manager GridLayout : range dans une grille/matrice de gauche à droite et de haut en bas. Constructeurs : GridLayout(int ligne, int colonne) range les composants dans la grille de rangement. GridLayout(int ligne, int colonne, int hspacing, int vspacing) idem avec le vspacing et le hspacing spécifiés. BorderLayout : divise un composant container en 5 zones: North, East, South, West, Center BorderLayout() crée 5 zones. BorderLayout(int hspacing, int vspacing) idem avec un espacement spécifié. La méthode add doit être utilisé ainsi : add("North", composant).
Exemple : Frame import java.awt.Button; import java.awt.GridLayout; import java.awt.Frame; public class Maframe extends Frame { public Maframe() { setLayout (new GridLayout (4,3)); for (int num=1; num <= 9 ; num++) add(new Button(Integer.toString(num))); add(new Button("*")); add(new Button("0")); add(new Button("# ")); setVisible(true); pack(); } public static void main(String args[]) { new Maframe(); }} java.awt Class Frame java.lang.Object java.awt.Component java.awt.Container java.awt.Window java.awt.Frame Classe Container Classe Component Classe Frame
Evénements import java.awt.Button; import java.awt.Label; Mettre en place un "écouteur" (listener). import java.awt.Button; import java.awt.Label; import java.applet.Applet; import java.awt.Color; public class Prog46 extends Applet { public void init() { Button monBouton = new Button ("Changer"); add(monBouton); Label monLabel = new Label ("Changer"); add(monLabel); monLabel.setForeground(Color.red); monBouton.addActionListener(new Delegue1(monLabel)); } Un Button émet un événement ActionEvent lorsqu'il est pressé/cliqué. Par défaut, personne n'écoute/ne reçoit cet événement, qui est perdu. La méthode addActionListener() spécifie que désormais un objet Delegue1 écoutera/sera récepteur d'un tel événement, l'objet Delegue1 reçoit le Label en paramètre.
Evénements import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.Label; import java.awt.Color; public class Delegue1 implements ActionListener { private Label leLabel; private boolean etatLabel; public Delegue1(Label lab) { leLabel = lab; etatLabel=true; } public void actionPerformed (ActionEvent event) { etatLabel = ! etatLabel; if (etatLabel) leLabel.setForeground (Color.red); else leLabel.setForeground (Color.blue); Delegue1 implémente l'interface ActionListener puisqu'il est susceptible de recevoir de tel événement. La réception d'un tel événement provoque l'exécution de la méthode actionPerformed. Ici, la méthode actionPerformed change la couleur du label de notre Applet puisque l'objet Delegue1 à une référence sur le label. Label est un Component dont la méthode setForeground est héritée.
Evénements Button Button : permet le déclanchement d'action. Par défaut le nom de l'action d'un bouton est son texte. Méthodes : setActionCommand (String texte) spécifie le nom de l'action du bouton. getActionCommand() retourne le nom de l'action du bouton. addActionListener(ActionListener écouteur) met un "écouteur" d'événement sur le bouton. removeActionListener(ActionListener écouteur) supprime un "écouteur" d'événement sur le bouton.
Délégué qui peut agir sur l'objet où s'est produit l'événement add(maListe); monLabel = new Label ("Choisir"); add(monLabel); maListe.addActionListener(new Delegue2(this)); } public void changeLabel () { int index = maListe.getSelectedIndex(); monLabel.setForeground(tabCouleur[index]); import java.awt.List; import java.awt.Label; import java.applet.Applet; public class Prog47 extends Applet { private List maListe; private Label monLabel; private final Color tabCouleur[]= {Color.red,Color.blue, Color.green, Color.yellow, Color.orange }; public void init() { maListe = new List(3); maListe.add("bleu"); maListe.add("rouge"); maListe.add("vert"); maListe.add("jaune"); maListe.add("orange"); Delegue2 reçoit l'objet Applet en paramètre : donc le Delegue2 aura une référence sur l'Applet. La méthode changeLabel de changement de couleur du label est prévue. Lors d'une sélection de choix d'une List (double-cliquez !), l'événement ActionListener est envoyé.
Délégué qui peut agir sur l'objet où s'est produit l'événement import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.Label; import java.awt.List; import java.awt.Color; public class Delegue2 implements ActionListener { private Prog47 monApplet; public Delegue2 (Prog47 monApp) { monApplet = monApp; } public void actionPerformed (ActionEvent event) { monApplet.changeLabel();
Menus import java.awt.MenuBar; import java.awt.MenuItem; import java.awt.Label; import java.applet.Applet; import java.awt.Color; public class Prog48 extends Applet { private Label monLabel; public void init ( ) { Delegue3 monDelegue= new Delegue3 (this); MenuBar maBarreDeMenu = new MenuBar(); add (maBarreDeMenu); Menu menu1 = new Menu("fond"); maBarreDeMenu.add(menu1); MenuItem m1rouge = new MenuItem("fond rouge"); m1rouge.addActionListener (monDelegue); menu1.add (m1rouge); MenuItem m1bleu = new MenuItem ("fond bleu"); m1bleu.addActionListener (monDelegue); menu1.add (m1bleu); MenuItem m1vert = new MenuItem ("fond vert"); m1vert.addActionListener (monDelegue); menu1.add (m1vert); menu1.addSeparator ( ); Menus MenuItem m1noir = new MenuItem ("fond noir"); m1noir.addActionListener (monDelegue); menu1.add (m1noir); Menu menu2 = new Menu ("texte"); maBarreDeMenu.add (menu2); MenuItem m2rouge = new MenuItem ("texte rouge"); m2rouge.addActionListener(monDelegue); menu2.add (m2rouge); MenuItem m2bleu = new MenuItem ("texte bleu"); m2bleu.addActionListener (monDelegue); menu2.add (m2bleu); MenuItem m2vert = new MenuItem ("texte vert"); m2vert.addActionListener (monDelegue); menu2.add (m2vert); MenuItem m2noir = new MenuItem ("texte noir"); m2noir.addActionListener (monDelegue); menu2.add (m2noir); monLabel = new Label ("Changer"); add (monLabel); setVisible (true); pack(); } public void changeLabelFond (Color couleur) { monLabel.setBackground (couleur); } public void changeLabelTexte (Color couleur) { monLabel.setForeground (couleur); }}
Menus import java.awt.event.ActionListener; import java.awt.event.ActionEvent; import java.awt.Color; public class Delegue3 implements ActionListener { private Prog48 monApplet; public Delegue3 (Prog48 app) { monApplet = app; } public void actionPerformed (ActionEvent event) { Color couleur= Color.white; String nomDeMenuChoisi = event.getActionCommand(); if (nomDeMenuChoisi.indexOf ("rouge")>=0) couleur = Color.red; else if (nomDeMenuChoisi.indexOf ("bleu")>=0) couleur = Color.blue; else if (nomDeMenuChoisi.indexOf ("vert")>=0) couleur = Color.green; else if (nomDeMenuChoisi.indexOf ("noir")>=0) couleur = Color.black; if (nomDeMenuChoisi.indexOf ("fond")>=0) monApplet.changeLabelFond (couleur); if (nomDeMenuChoisi.indexOf ("texte")>=0) monApplet.changeLabelTexte (couleur); } } L'objet délégué ou listener doit distinguer d'ou vient l'événement pour pouvoir agir, dans l'événement passée en paramètre de la méthode actionPerformed, se trouve les informations relatives à l'événement qui s'est produit en particulier, par la méthode getActionCommand, on récupère le nom d'action. Comme les noms d'actions étaient les mêmes que les noms d'items de menus, il est possible de savoir quel item a été sélectionné.
Utiliser les valeurs modifiées de TextField import java.awt.TextField; import java.awt.Label; import java.applet.Applet; import java.awt.Color; public class Prog49 extends Applet { private TextField valeurR, valeurV, valeurB; private Label monLabel; public void init ( ) { monLabel = new Label ("intensité couleur [0-255]"); add (monLabel); Delegue4 monDelegue= new Delegue4 (this); add (new Label ("R:")); valeurR = new TextField ("255",3); add (valeurR); valeurR.addActionListener (monDelegue); add (new Label ("V:")); valeurV = new TextField ("255",3); add (valeurV); valeurV.addActionListener (monDelegue); add (new Label ("B:")); valeurB = new TextField ("255",3); add (valeurB); valeurB.addActionListener (monDelegue); } private int convertir (String intensite) { int val= (new Integer(intensite)).intValue(); if (val <0) return 0; else if (val >255) return 255; else return val; } public void changeLabel ( ) { int r = convertir (valeurR.getText()); int v = convertir (valeurV.getText()); int b = convertir (valeurB.getText()); monLabel.setBackground (new Color(r,v,b)); }} Un TextField envoie aussi un événement ActionEvent lorsque la modification du texte est confirmée par la frappe de la touche "entrée" le texte d'un TextField est récupérée par la méthode getText(). Les couleurs peuvent être crées en précisant les intensités RVB (rouge, vert, bleu) sur 8 bits chacune donc un entier entre 0 et 255.
Utiliser les valeurs modifiées de TextField import java.awt.event.ActionListener; import java.awt.event.ActionEvent; public class Delegue4 implements ActionListener { private Prog49 monApplet; public Delegue4 (Prog49 monApp) { monApplet = monApp; } public void actionPerformed (ActionEvent event) { monApplet.changeLabel ( );
ActionListener Les événements sont des actions ou des effets indirects d'action de l'utilisateur du GUI (Interface Graphique Utilisateur) : clic de souris, frappe de touche, fenêtre masquée par une autre, ...qu'il faut gérer en mettant en place un "écouteur" de l'événement souhaité sur le composant graphique considéré, puis définir le comportement (les instructions à exécuter, le Handler d'événement) lorsque l'événement surviendra. ActionListener est une interface pour écouter et traiter les ActionEvents. Par exemple, bouton.addActionListener (composant) met un écouteur (d'ActionEvent) sur le bouton, le "Handler" sera assurée au niveau du composant désigné qui implémente l'ActionListener; pour un bouton, l'ActionEvent est provoquée par un clic de souris (bouton enfoncé puis relâché). removeActionListener(ActionListener écouteur) supprime un "écouteur" d'événement. La classe qui implémente l'interface ActionListener doit définir la méthode : public void actionPerformed(ActionEvent e) { ... qui est le "Handler" getActionCommand() est une méthode de ActionEvent récupère le nom de la commande d'action associé au composant par exemple un bouton (par défaut son label).
Evénements des Frames et la classe siège de l'événement qui est son propre délégué import java.awt.Label; import java.awt.Frame; import java.awt.event.WindowListener; import java.awt.event.WindowEvent; import java.awt.FlowLayout; public class Prog71 extends Frame implements WindowListener { public static void main(String args[]) { new Prog71(); } public Prog71() { setTitle("Prog71"); setSize(200,100); setLayout(new FlowLayout(FlowLayout.CENTER)); setVisible(true); addWindowListener (this); public void windowClosing (WindowEvent e) { add (new Label("fini dans 5 secondes !")); pack(); try { Thread.sleep (5000); } catch (InterruptedException ie) { System.exit (1); } setVisible (false); dispose (); System.exit (0); public void windowOpened(WindowEvent e) {} public void windowActivated(WindowEvent e) {} public void windowDeactivated(WindowEvent e) {} public void windowClosed(WindowEvent e) {} public void windowIconified(WindowEvent e) {} public void windowDeiconified(WindowEvent e) {}
Lignes de la classe La Frame peut être le siège de plusieurs événements WindowEvent : Ouvrir la Frame. La rendre active ou passive. La mettre en icone ou l'inverse. La fermer par le window manager (ou bureau) : windowClosing. La fermer par la méthode dispose() : windowClosed. L'objet Prog71 est le siège d'événements WindowEvent et est aussi le délégué (le listener) de cet événement par l'instruction : addWindowListener(this); La méthode static sleep de la classe Thread attend le nombre de millisecondes indiquées dispose est la méthode qui ferme la Frame et toutes ses sous-fenêtres s'il y a.
Evénements en résumé Composant Action Evénement Interface d'écoute Button, List, MenuItem, TextField, Checkbox, Canvas Sélectionner, valider ActionEvent ActionListener TextArea, TextField Changer le texte TextEvent TextListener Frame Ouvrir, fermer WindowEvent WindowListener Container Mouvement et clic de souris, frappe au clavier MouseEvent, MouseMotionEvent, KeyEvent MouseListener, MouseMotionListener, KeyListener
Technique des Adapters addWindowListener (new WindowAdapter() { public void windowClosing(WindowEvent e) { add(new Label("fini dans 5 secondes !")); pack(); try { Thread.sleep(5000); } catch (InterruptedException ie) { System.exit(1); } setVisible(false); dispose(); System.exit(0); public void windowDeiconified(WindowEvent e) { Dimension dim=getSize(); setSize(dim.width, dim.height); }); setVisible(true); }} import java.awt.Frame; import java.awt.Dimension; import java.awt.Label; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.FlowLayout; public class Prog72 extends Frame { public static void main(String args[]) { new Prog72(); } public Prog72() { setTitle("Prog72"); setSize(200,100); setLayout(new FlowLayout(FlowLayout.CENTER));
WindowAdapter La classe WindowAdapter est un écouteur prédéfinie (un délégué) qui implémente l'interface WindowListener (c’est une classe abstraite qui contient 10 méthodes), c’est une classe "écouteur" pour les fenêtres Frame, Dialog, ... Dans Prog72, nous redéfinissons uniquement les méthodes dont nous avons besoin : windowClosing et windowDeiconified. Cela se fait en mettant l'instanciation d'une classe sans nom qui est sous classe de windowAdapter suivies des redéfinitions de méthodes (cette classe est une inner-classe). Les Classes Adapters évite l'implémentation de toutes les méthodes abstraites d'une interface Listener. L'interface WindowListener déclare 7 méthodes abstraites qui sont, dans la classe WindowAdapter définies avec le corps {}; En Pratique, il faut : Créer une sous-classe Ecouteur de WindowAdapter et redéfinir les méthodes souhaitées : par exemple, public void windowClosing(WindowEvent e) { ... }; et dans le composant à l'"écoute" d'un évènement "fermeture de fenêtre", mettre en place l'écoute : addWindowListener(objetEcouteur); Ou utiliser la technique d'inner classe décrite ci-dessus.
Application graphique : Editer un fichier import java.awt.*; import java.io.*; import java.awt.event.*; public class EditerFichier extends Frame implements ActionListener { TextArea texte; String messageFichier="Donnez ici un nom de fichier"; String messageTexte="Saisir le texte ici"; TextField champFichier; public static void main(String[] args) { new EditerFichier(); } public EditerFichier() { this.setTitle("Editer un Fichier"); texte= new TextArea(messageTexte, 20,50); texte.setEditable(true); this.add("Center",texte); champFichier= new TextField(messageFichier,20); this.add("South",champFichier); MenuBar barreMenu= new MenuBar(); this.setMenuBar(barreMenu); Menu menuFichier= new Menu("Fichier"); barreMenu.add(menuFichier); MenuItem menuOuvrir= new MenuItem("Ouvrir"); menuOuvrir.addActionListener(this); menuFichier.add(menuOuvrir); MenuItem menuEnregistrer= new MenuItem("Enregistrer"); menuEnregistrer.addActionListener(this); menuFichier.add(menuEnregistrer); MenuItem menuQuitter= new MenuItem("Quitter"); menuQuitter.addActionListener(this); menuFichier.add(menuQuitter); this.pack(); this.setVisible(true); }
Application graphique : Editer un fichier char car=0; while (dejaLu < longueurFichier) { car= (char)flotLecture.read(); dejaLu = dejaLu + 1; texte.append(String.valueOf(car)); } flotLecture.close(); } catch (IOException e) { System.out.println(" erreur :" + e.toString()); } } public void enregistrerFichier(String nomFichier) { Fichier fichier= new Fichier(nomFichier); if (fichier.ecrirePossible()) { try { FileWriter flotEcriture = new FileWriter(fichier); flotEcriture.write(texte.getText()); flotEcriture.close(); System.out.println(" erreur :" + e.toString()); } texte.setText(messageTexte); } champFichier.setText(messageFichier); }} public void actionPerformed (ActionEvent e) { String menuSelectionne= e.getActionCommand(); if (menuSelectionne.equals("Quitter")) { this.setVisible(false); this.dispose(); System.exit(0); } else if (menuSelectionne.equals("Enregistrer")) { if(!champFichier.getText().equals(messageFichier)) enregistrerFichier(champFichier.getText()); } else if (menuSelectionne.equals("Ouvrir")) chargerFichier(champFichier.getText()); } public void chargerFichier(String nomFichier) { Fichier fichier= new Fichier(nomFichier); if (!fichier.lirePossible()) { champFichier.setText(messageFichier); return; } texte.setText(""); try { FileReader flotLecture = new FileReader(fichier); long longueurFichier= fichier.length(); int dejaLu = 0;
Application graphique : Editer un fichier
Longueur de l'arc à tracer Exercice Le but de ce TP est d'écrire un programme qui permet de tracer des arcs (pleins ou en fil de fer) en lisant au clavier les valeurs de l'angle de départ et la longueur de l'arc à tracer (sous forme d'angle également) : Longueur de l'arc à tracer Angle de départ
Exercice Regarder dans la documentation Java à quoi servent les deux méthodes drawArc et FillArc de la classe Graphics et comment elles s'utilisent. Regarder la documentation de la classe Canvas : vous remarquerez notamment qu'on doit écrire une méthode paint lorsqu'on étend la classe Canvas. Regarder à quoi ressemble cette méthode paint dans la classe Canvas, ainsi que les méthodes update et repaint dans la classe Component. Ecrire une classe MonCanvas qui étend la classe Canvas et qui a trois attributs : angleDebut et angleTotal sont des entiers et permettent de savoir à partir de quel angle on dessine et sur quelle longueur d'arc, le booléen plein indique si on dessine en fil de fer (false) ou pas (true); cette classe contiendra une méthode paint.
Exercice Ecrire la méthode paint qui permet de dessiner l'arc (soit plein, soit en fil de fer) en rouge (utiliser setColor de la classe Graphics), ainsi que les deux axes du repère en noir, et éventuellement des graduations comme sur la figure ci-dessous (utiliser pour cela la méthode getBounds de la classe Component ou les méthodes getWidth et getHeight). Ecrire une classe MonPanel permettant de mettre en place l'interface du programme : les boutons en bas, le canvas au dessus. On pourra tout écrire dans le constructeur, sans rien mettre en attribut. Ecrire une classe MonEcouteur qui contient deux attributs de type TextField et un attribut de type Canvas. Cette classe est chargée de mettre à jour le booléen plein et les deux entiers angleDebut et angleTotal et de rafraichir l'affichage lorsqu'on clique sur l'un des boutons. Ecrire une classe TestCanvas contenant une méthode main pour tester le programme.
Révision
Héritage entre composants Object Component Window Frame Classes abstraites Graphics MenuComponent Button Canvas Checkbox Container Label List MenuItem CheckboxMenuItem Menu MenuBar Fenêtre top-level Fenêtre ordinaire Panel Applet
Geometry manager BorderLayout : Divise un composant container en 5 zones: North, East, South, West, Center. Constructeurs : BorderLayout() crée 5 zones. BorderLayout(int hspacing, int vspacing) idem avec un espacement spécifié. La méthode add doit être utilisé ainsi : add ("North", composant). Les frames sont gérées par défaut par le gestionnaire BorderLayout
Geometry manager FlowLayout : Range de gauche à droite et de haut en bas. Constructeurs : FlowLayout() range les composants en les centrant avec un "vspacing et hspacing" (espace vertival, respectivement horizontal) de 5 pixels. FlowLayout(int aligne) range les composants en les alignant selon aligne : FlowLayout.LEFT, FlowLayout.CENTER, FlowLayout.RIGHT avec un vspacing et hspacing de 5 pixels. FlowLayout(int aligne, int hspacing, int vspacing) range selon l'alignement et le vspacing et le hspacing spécifiés. Le geometry manager de Panel est par défaut le FlowLayout manager
Geometry manager GridLayout : Range dans une grille/matrice de gauche à droite et de haut en bas. Constructeurs : GridLayout(int ligne, int colonne) range les composants dans la grille de rangement. GridLayout(int ligne, int colonne, int hspacing, int vspacing) idem avec le vspacing et le hspacing spécifiés. setLayout détermine le nouveau geometry manager
Evénements en résumé Composant Action Evénement Interface d'écoute Button, List, MenuItem, TextField, Checkbox, Canvas Sélectionner, valider ActionEvent ActionListener TextArea, TextField Changer le texte TextEvent TextListener Frame Ouvrir, fermer WindowEvent WindowListener Container Mouvement et clic de souris, frappe au clavier MouseEvent, MouseMotionEvent, KeyEvent MouseListener, MouseMotionListener, KeyListener