23 - Classe abstraite ** permet de définir des méthodes sans les

23 - Classe abstraite
� permet de définir des méthodes sans les implémenter : méthode abstraite
abstract <definition_de_methode>;
� classe abstraite
abstract <definition_de_classe>
{ ...
� une classe abstraite n'est pas instanciable
� on peut définir une classe abstraite sans méthode abstraite
� une sous-classe non abstraite d'une classe abstraite doit définir explicitement toutes les
méthodes abstraites
abstract class GeometriePlane
{ static final double PI=3.14159 ;
abstract double perimetre();
abstract double surface();}
class Rectangle extends GeometriePlane
{ double largeur,longueur;
double perimetre()
{return 2*(largeur+longueur);}
double surface()
{return largeur*longueur;}}
Exemple
24 - Interface
� "classe" entièrement abstraite
� sans variable d'instance, avec des méthodes abstraites et des constantes uniquement
� interface publique
� toutes les méthodes sont implicitement abstraites et publiques et héritées par toute classe qui
implémente l'interface
� classe qui implémente une interface doit définir toutes ses méthodes pour être instanciable
(non abstraite)
� Une classe peut
� hériter d'une classe au plus
� MAIS, implémenter plusieurs
interfaces
� Une interface peut "hériter" de
plusieurs interfaces
Héritage multiple
� pour définir un type abstrait : une interface
décrit un ensemble de comportements, mais ne
les implémente pas
� pour implémenter l'héritage multiple
Pourquoi utiliser une interface?
interface Geometrie
{static final double PI=3.14159 ;}
interface Courbe extends Geometrie
{ double longueur();}
interface Surface extends Geometrie
{ double surface() ;}
Exemple
class Rectangle
implements Courbe, Surface
{ double largeur,longue;
public double longueur()
{return 2*(largeur+longue);}
public double surface()
{return largeur*longue;}}
Interface I1
m()
class C

m()
Interface I2
m()
implements
Si les méthodes m() de I1 et I2 ont la même signature et :
- même type de retour : C doit implémenter m()
- des types de retour différents : impossible
Si les méthodes m() de I1 et I2 n'ont la même signature
C doit implémenter les deux méthodes m()
25 – Classes internes
Classe définie dans une autre classe
Quatre types différents :
� Classes internes membres
� Classes internes membres statiques
� Classes internes locales
� Classes internes anonymes
Classe interne membre
� permet de définir plusieurs instances de la classe interne, liés à une même instance de la
classe englobante
class Ext
{ int var;
public class Interne
{//accède à toutes les variables de Ext
int x;
this.x=Ext.this.var;
}
. . .
}
Ext o=new Ext();
Ext.Interne i1=o.new Interne();
Ext.Interne i2=o.new Interne();
Création d'objets internes
Classe interne membre
statique
class Ext
{ static int var;
static public class IntStat
{//accède aux variables statiques de Ext
int x;
x=var;
}
. . .
}
Ext o1=new Ext();
Ext o2=new Ext();
Ext.IntStat i1=new Ext.IntStat();
Ext.IntStat i2=new Ext.IntStat();
Création d'objets internes
Classe interne locale
class Ext
{ final int var;
public Iterator m()
{ class IteratorSpecial implements Iterator
{//accède aux variables final accessibles de Ext
public boolean hasNext() {. . .}
public Object next() {. . .}
public void remove() {. . .}
}//class IteratorSpecial
return new IteratorSpecial();
}//methode m()
. . .

}// class Ext
Ext o1=new Ext();
Iterator i=e.m();
while (i.haxNext())
{ . . . i.next(). . .
Création d'objets internes
Classe interne anonyme
class Ext
{ final int var;
public Iterator m()
{
return new Iterator(){
public boolean hasNext() {. . .}
public Object next() {. . .}
public void remove() {. . .}
}; //new
}//methode m()
. . .
}// class Ext
Ext e=new Ext();
Iterator i=e.m();
while (i.haxNext())
{ . . . i.next(). . .
Création d'objets internes
Quand utiliser une classe anonyme?
� quand une seule instance est nécessaire
� quand le nom de la classe interne locale n'est pas utile
� pour écrire un code plus concis
� AWT
� SWING
II - Interfaces graphiques
� composants légers, écrits en Java, indépendants du système natif
� pluggable look and feel
� ensemble d'outils graphiques beaucoup plus important que dans AWT
� inclus dans le JDK depuis la versions 1.2
Une première fenêtre
public class Fenetre extends Frame
{ final static int HTAILLE=550;
final static int VTAILLE=450;
public Fenetre(){
setTitle("Ma première fenêtre");
setSize(HTAILLE,VTAILLE);
setVisible(true);}}
Avec ce code, la fenêtre ne peut pas se fermer …
Ouvrir la fenêtre
class Test{
public static void main(String arg[]){
Fenetre f=new Fenetre();}}
Toute application graphique commence par créer un objet Frame
Dessiner
� utiliser la classe Graphics
package java.awt
� méthodes de la classe Graphics :
clearRect() drawLine() drawRect() drawOval()
drawArc() drawImage()
fillRect() fillOval() drawString() setColor()
…
� origine du système de coordonnées : coin haut
gauche
Affichage du dessin
� un objet Component se dessine lorqu'il reçoit le message

paint()
� la méthode paint() est appelée quand le dessin d’un objet Component doit être mis à jour
(première visualisation, changement de taille, réaffichage)
� l'objet est redessiné complètement à chaque appel de la méthode paint()
� les méthodes update() et repaint() permettent de mettre à jour l'objet
La méthode paint(Graphics gc)
� définie dans Component, ne fait rien
� doit être redéfinie dans des classes dérivées de
Frame, Canvas, Applet, pour dessiner l’objet s’il
n’est pas utilisé comme objet Container
� l'objet Graphics en argument
� représente le contexte graphique de l’objet
Component
� reçoit les messages permettant de dessiner
� est fourni par la machine virtuelle
La classe java.awt.Graphics
� est abstraite
� regroupe toutes les méthodes de dessin
� ne peut pas être instanciée par un new
� accès aux instances de la classe avec les méthodes paint(), update() et getGraphics()
d'un objet Component
Contexte graphique Exemple
public class Fenetre extends Frame
{ public Fenetre()
{}p{}ub.l.i.c vogi.ddrpaawiSnttr(iGnrga(p"hHieclslog"),100,100);
}
Méthodes repaint() et update()
La méthode update()
� est appelée indirectement par la méthode repaint()
� remplit le composant avec sa couleur de fond
� initialise la couleur du premier plan
� appelle paint()pour redessiner l'objet Component
La classe java.awt.Component
� classe abstraite
� super-classe de Canvas, Container, Frame,
Applet, Button,…
� méthodes :
getParent() getPeer() getToolkit()
getBackground() setBackground()
getForeground() setForeground()
paint() repaint() update() …
Classes dérivées
� objets Container
utilisés pour contenir d'autres objets ou pour afficher directement des dessins
� Window
Dialog : boîtes de dialogue ayant un cadre et
un titre
Frame : fenêtres du système graphique de
l'hôte
� Panel : objets utilisés comme zone d'affichage pour ajouter des composants ou dessiner
directement
� objets Canvas
rectangles blancs utilisés pour définir des composants graphiques personnalisés dessinés en
utilisant les méthodes de la classe Graphics
� autres objets
Button, Chekbox, List, Choice, Label

Scollbar, TextComponent
Disposition des composants
� Chaque objet Container mémorise la liste des
objets qui lui sont ajoutés (add() ) ou enlevés (remove() )
� Un objet Container dispose ses composants à l'écran en utilisant un objet Layout associé qui
gère la disposition
� quelques méthodes de la classe Container
public Component add(Component c)
public Component add(String name, Component c)
public Component add(Component c, Object Constraints)
Objets LayoutManager
� gèrent la mise en page des composants d'interface
� différents types : FlowLayout, BorderLayout,
GridLayout, CardLayout, GridBagLayout
� les objets Container ont un gestionnaire par défaut
pour Panel et Applet : FlowLayout
pour Window, Dialog et Frame : BorderLayout
� choix d'un gestionnaire de mise en
forme
avec la méthode setLayout()
� exemple :
setLayout(new FlowLayout());
Objets MenuComponent
Menu : un objet Menu contient des objets MenuItem
MenuBar
MenuItem
Exemple : un éditeurgraphique
Une classe FenetreEditeur
public class FenetreEditeur extends Frame
{ final static int HTAILLE=550;
final static int VTAILLE=450;
public FenetreEditeur()
{
setTitle("Editeur graphique");
setSize(HTAILLE,VTAILLE);
setVisible(true);}}
Une classe MenuEditeur
public class MenuEditeur extends MenuBar
{ public MenuItem menuNouveau, menuQuitter, menuApropos public MenuEditeur(){
Menu menuFichier = new Menu("Fichier");
menuNouveau = new MenuItem("Nouveau");
menuQuitter = new MenuItem("Quitter");
menuFichier.add(menuNouveau) ;
menuFichier.add(menuQuitter) ;
Menu menuAide = new Menu("aide");
menuApropos = new MenuItem("Apropos");
menuAide.add(menuApropos);
add(menuFichier);
add(menuAide); }
seul un objet Frame peut contenir un menu
public FenetreEditeur(){
setTitle("Editeur graphique");
setMenuBar(new MenuEditeur());
setSize(HTAILLE,VTAILLE);
setVisible(true);}
Ajouter un objet Menu
Ajouter une objet Panel
public class BarreOutils extends Panel{
public BarreOutils(){