cm03-abstraction.pdf — March 22, 2005 — 1

(1)

as

Architecture des Systèmes d’Information

Plan Classes abstraites Interface Classes/Interfaces internes

Programmation

- Classes abstraites, Interfaces et classes imbriqu´ ees -

Nicolas Malandain

March 22, 2005

Classes abstraites, Interfaces et classes imbriqu´ees 1 / 21

as

Architecture des Systèmes d’Information

Plan Classes abstraites Interface Classes/Interfaces internes

1 Classes abstraites Principe En Java Exemple

2 Interface Principe En Java Exemple 1 Exemple 2

3 Classes/Interfaces internes Principes

Exemple : interne static Exemple : interne

Plan Classes abstraites Interface Classes/Interfaces internes Principe En Java Exemple

Classes abstraites

Principe

Permet la définition de types incomplets le comportement est connu mais non défini (méthode abstraite⇒classe abstraite) le comportement est incomplet (classe abstraite)

Permet de définir un type commun à plusieurs classes concrètes

Classe abstraite

D´efinition

Classe considérée incomplète donc non instanciable

Syntaxe

abstract class ClasseAbstraite { ...

}

(2)

M´ ethode abstraite

D´efinition

Méthode incomplète : déclarée mais non définie (pas de corps)

⇒classe abstraite

Syntaxe

abstract class ClasseAbstraite { abstract void methodeAbstraite(...);

}

Remarque

Toute classe héritant d’une classe contenant des méthodes abstraites est abtraite si elle ne définit pas toutes les méthodes abstraites

Figure.java

package fr.insarouen.asi.prog.cours3;

public abstract class Figure {

private static int compteurIdentifiant;

private int identifiant;

public Figure() {

identifiant=compteurIdentifiant++;

}

public abstract double surface();

public String toString() {

return getClass().getSimpleName()+"("+identifiant+") : "+surface();

} }

LeRectangle.java

packagefr.insarouen.asi.prog.cours3;

public class LeRectangleextendsFigure { private doublelongueur, largeur;

public LeRectangle(double_longueur,double_largeur) { longueur = _longueur;

largeur = _largeur;

}

public doublesurface() { returnlongueur*largeur;

} }

LeCarre.java

public class LeCarreextendsLeRectangle { public LeCarre(doublecote) {

super(cote,cote);

} }

LeCercle.java

public class LeCercleextendsFigure { private doublerayon;

public LeCercle(double_rayon) { rayon = _rayon;

}

public double surface() { returnMath.PI*rayon*rayon;

} }

ClassesAbstraites.java

import java.util.Arrays;

public class ClassesAbstraites {

public static void main(String[] args) {

Figure[] figures={new LeCarre(20),new LeRectangle(15,10), newLeCercle(10)};

System.out.println(Arrays.toString(figures));

} }

(3)

Plan Classes abstraites Interface Classes/Interfaces internes Principe En Java Exemple 1 Exemple 2

Interface

M´etaphore

“Les interfaces sont un peu comme les décorations des scouts. Lorsqu’un scout a appris à construire une cabane, il peut se promener avec une petite décoration sur l’une de ses manches. Cela indique à tout le monde : je sais comment construire une cabane”

“Java par la pratique”(O’Reilly) P. Niemeyer & J. Peck.

Principe

Une interface est quasi ´equivalente `a une “classe abstraite pure”

Son utilisation peut ˆetre vue comme un “h´eritage comportementale”

Elle permet la d´eclaration de comportement identiques dans des arbres de classes diff´erents

Propri´et´es :

les attributs sontpublic static final (⇔constantes) les m´ethodes sont toutesabstract public

les interfaces acceptent l’h´eritage multiple entre elles une seuleinterface publicpar fichier (idemclass) non instanciable

Syntaxe D´eclaration

interface NomInterface {

// attributs (par défaut public, static, final) // méthodes (par défaut abstract, public) }

Utilisation

class LaClasse implements NomInterface1, ... { }

Rotation.java

public interface Rotation {

void tourner(int px, int py, int angle);

}

Translation.java

public interface Translation { void translater(int vx, int vy);

}

Transformation.java

public interface Transformation extendsRotation, Translation { }

Toute classe peut maintenant impl´ementer une ou plusieurs de ces interfaces

ClassesAbstraitesInterfaces.java

importjava.util.Arrays;

public class ClassesAbstraitesInterfaces { public static voidmain(String[] args) {

Figure[] figures={newLeCarre(20),new LeRectangle(15,10),new LeCercle(10)};

Ordre.trier(figures);

System.out.println(Arrays.toString(figures));

Voiture[] voitures={newVoiture("1234SZ76",6),new Voiture("5678AZ27",10), new Voiture("910XE61",2)};

Ordre.trier(voitures);

System.out.println(Arrays.toString(voitures));

} }

InterfaceComparable

public interface InterfaceComparable {

int compareA(InterfaceComparable comparable);

}

(4)

Ordre.java

public class Ordre {

private static voidechanger(InterfaceComparable[] tableau, inta, intb) { InterfaceComparable tmp;

tmp=tableau[a];

tableau[a]=tableau[b];

tableau[b]=tmp;

}

private static int trouverIndiceDuMax(InterfaceComparable[] tableau,intdebut,intfin) { if (debut<0 || fin>=tableau.length || debut>fin)

return-1;

int indiceDuMax=debut;

for(inti=debut; i<=fin; i++)

if (tableau[indiceDuMax].compareA(tableau[i])<0) indiceDuMax = i;

returnindiceDuMax;

}

public static voidtrier(InterfaceComparable[] tableau) { if (tableau.length<2)

return;

int indiceDuMax;

for(intdernierePlace=tableau.length-1; dernierePlace>0; dernierePlace--) { indiceDuMax=trouverIndiceDuMax(tableau,0,dernierePlace);

echanger(tableau,indiceDuMax,dernierePlace);

} } }

reprise deFigure.java

public abstract class FigureimplementsInterfaceComparable { ...

public abstract doublesurface();

public int compareA(InterfaceComparable c) { if (c instanceofFigure)

if (surface() > ((Figure)c).surface()) return1;

else

if (surface() < ((Figure)c).surface()) return-1;

return0;

} ...

}

Voiture.java

public class VoitureimplementsInterfaceComparable { private String immatriculation;

private int puissance;

public Voiture(String _immatriculation,int_puissance) { immatriculation = _immatriculation; puissance = _puissance;

}

public int getPuissance() { returnpuissance;

}

public String getImmatriculation() { returnimmatriculation;

}

public int compareA(InterfaceComparable c) { if (c instanceofVoiture)

if (puissance > ((Voiture)c).getPuissance()) return1;

else

if (puissance < ((Voiture)c).getPuissance()) return-1;

return0;

}

public String toString() {

returnimmatriculation+"("+puissance+")";

} }

Plan Classes abstraites Interface Classes/Interfaces internes Principes Exemple : interne static Exemple : interne

Description

Principe

D´eclaration d’une classe dans une autre

Les classes internes permettent de renforcer les relations entre deux classes.

Par exemple : un curseur texte n’a de sens que dans un composant texte(Tutoriel Java de SUN,http: // java. sun. com)

(5)

Quatre types de classes internes. . .

classe interne (inner class)

Une instance n’existe que dans une instance englobante. Tous les membres de classe englobante lui sont accessibles (r´ef´erences : this et ClasseEnglobante.this).

Une interface ne peut ˆetre de ce type car non instanciable

classe interne static (nested class)

Elle accède aux membres statiques de la classe englobante. Elle ne possède pas de référence sur l’objet englobant l’ayant créé

classe locale

Ce type de classe est déclaré dans une méthode et à le même

comportement qu’une classe interne. Sa port´ee est locale au bloc, elle peut acc´eder aux membres de la classe englobante et uniquement aux variables localesfinal du bloc.

classe anonyme

Il s’agit d’une classe locale ne portant de nom (hériste d’une classe abstraite ou non, ou implémente une interface). Elle est instancié au moment de sa déclaration.

Elle est utilis´ee lors d’un besoin unique.

ListeChainee.java

public classListeChainee { private Noeud tete;

public static classNoeud { privateObject valeur;

privateNoeud suivant;

public Noeud(Object valeur) { this.valeur = valeur;

}

public Noeud(Object valeur, Noeud suivant) { this.valeur = valeur;

this.suivant = suivant;

}

public voidsetValeur(Object valeur) { this.valeur = valeur;

}

public Object getValeur() { returnvaleur;

}

public Noeud getNoeudSuivant() { returnsuivant;

}

public voidsetNoeudSuivant(Noeud suivant) { this.suivant = suivant;

} }

publicListeChainee() { }

publicListeChainee(Object valeur) { tete =newNoeud(valeur);

}

publicNoeud getTete() { returntete;

}

public voidajouterEnTete(Object valeur) { tete =newNoeud(valeur, tete);

}

publicObject retirerTete() { Object obj=tete.getValeur();

tete=tete.getNoeudSuivant();

returnobj;

}

publicString toString() {

StringBuffer sb =newStringBuffer();

sb.append("ListeChainee : ");

Noeud courant = tete;

while(courant !=null) { sb.append(courant.getValeur());

sb.append(" / ");

courant = courant.getNoeudSuivant();

}

returnsb.toString();

} }

Jeu.java ...

public classJeu { privatePlateau plateau;

privatePersonnage[] personnages;

private intnbPersonnages;

private interface Joueur { public voidjouer();

}

public abstract class Personnage { protected intpv;

protected intvitesse;

publicPersonnage(intpv,intvitesse) { this.pv = pv;

this.vitesse = vitesse;

}

public voidsetVitesse(intvitesse) { this.vitesse = vitesse;

}

public intgetVitesse() { returnvitesse;

}

public voidsetPointVie(intpv) { this.pv = pv;

}

public intgetPointVie() { returnpv;

} }

private class MonstreextendsPersonnage implementsJoueur { publicMonstre() {

super(5, 10);

}

public voidjouer() {

System.out.println("Gnark gnark gnark !!!");

} }

private classHommeextendsPersonnage implementsJoueur { publicHomme() {

super(10, 4);

}

public voidsetVitesse(intvitesse) { if (plateau.auBord(this))

super.setVitesse(0);

else

super.setVitesse(vitesse);

}

public voidjouer() {

System.out.println("Je me prom`ene");

} }

(6)

Jeu.java(fin)

publicJeu(intnbPersonnagesMax) {

personnages=newPersonnage[nbPersonnagesMax];

}

publicPersonnage creerPersonnage() { if ( nbPersonnages < personnages.length)

if ((Math.random()*2) >= 1)

returnpersonnages[nbPersonnages++]=newMonstre();

else

returnpersonnages[nbPersonnages++]=newHomme();

return null;

}

public voideffectuerTourJeu() { for(inti=0; i<nbPersonnages; i++)

((Joueur)personnages[i]).jouer();

} }

idée générale : un jeu où un maˆıtre du jeu peut créer des Personnage, il peut uniquement modifier les vitesses ou les points de vie, mais en aucun cas les faire jouer un par un il ne peut qu’effectuer un tour de jeu pour tous via la classeJeu.

Plateau.java

public classPlateau {

// m´ethodes et attributs permettant de g´erer un plateau de jeu public booleanauBord(Jeu.Personnage p) {

return(Math.random()*2)>=1;// devrait tester la case }

}