18/12/2019

1. Idée de base d’une classe abstraite

 Par opposition à une classe concrète, une classe abstraite ne
peut pas être instanciée
 L'utilité d'une classe abstraite est de définir un type abstrait qui
regroupe des caractéristiques communes à d'autres types. En
Chapitre 6 : effet, elle sert :
 Comme racine pour un sous-arbre d’héritage :

Les classes abstraites et les interfaces  Dans lequel les sous-classes apporteront leurs
particularités
 Favorise le polymorphisme

 Au partage de certaines descriptions :

 Variables d’instances (ou de classes) communes

 Méthodes définissant un comportement par défaut

2. Définition d’une classe abstraite en JAVA

 Une méthode d'une classe abstraite peut ne pas avoir de code
(abstraite) si le niveau d'abstraction de la classe ne permet pas  Une classe abstraite est déclarée avec le mot clé abstract Exemple :
de définir un code réutilisable par les classes à dériver abstract class Document {….}
 Une classe abstraite ne peut jamais être instanciée par l'opérateur
Exemple : Document : Livre, Revue, … new
 On peut déclarer des références de type classe abstraite
 Une classe est définie abstraite par obligation (présence d’au  La méthode abstraite est aussi déclarée avec le mot clé abstract.
moins une méthode abstraite) ou par choix pour interdire la Exemple : abstract class ObjetGraphique
création d’objet
{abstract float surface ();
…
}

1
 18/12/2019

3. Les interfaces
 Si une classe comporte une méthode abstraite elle doit être
déclarée abstraite • Une interface est une forme particulière de classe qui comporte
uniquement des propriétés abstraites

 Une classe abstraite peut ne pas comporter de méthodes • Le concept d'interface est proposé par le langage JAVA pour
abstraites résoudre le problème de l'héritage multiple

 Toute classe concrète dérivée à partir d'une classe abstraite doit
donner un code aux méthodes abstraites héritées (donner une
implantation), si non elle doit être déclarée abstraite (l'abstraction
continue)
 On ne peut pas combiner les modificateurs abstract et final
• Une interface peut hériter de plusieurs interfaces en même
temps en utilisant le mot clé extends (héritage multiple)
• Comparée à une classe, une interface correspond à un type
comportant uniquement des méthodes abstraites et des
constantes statiques (on a pas à préciser les modificateurs
abstract, final et static)
• Les interfaces ne sont pas instanciables

• L’utilisation des interfaces permet de : • Une interface est définie d'une manière similaire à une classe
mais en utilisant le mot clé interface

– Définir (regrouper) des propriétés qui peuvent être transférées • La syntaxe de déclaration d'une interface est la suivante :
aux classes par un mécanisme particulier (l’implémentation) interface NomInterface { … }
– Garantir aux clients d’une classe que ses instances peuvent
assurer certains services, ou qu’elles possèdent certaines Exemples :
propriétés (par exemple, être comparables à d’autres interface Edition
instances) {void editer();}
interface Affichage
– Faire du polymorphisme avec des objets dont les classes {int MIN = 0;
n’appartiennent pas à la même hiérarchie d’héritage int MAX=100;
(l’interface joue le rôle de la classe mère)
void afficher();
}

2
 18/12/2019

4. Interfaces et héritage 5.Implémentation d’une interface

• Une interface peut hériter d'une ou de plusieurs autres • Une classe peut implémenter plusieurs interfaces, c'est à dire
interfaces. Il s'agit d'une extension de propriétés sous forme de avoir les même caractéristiques (ou propriétés) définies au niveau
méthodes abstraites et de constantes statiques. de ces interfaces. Réciproquement, la même interface peut être
Exemple : implémentée par plusieurs classes
interface InputStream // propriété d'accepter des caractères
{public int read(); } • L'implémentation est une forme d'héritage multiple
interface OutputStream // propriété de fournir des caractères
{public void write(int n); }
• Il est possible de combiner, lors de la définition d'une classe,
interface DataStream extends InputStream, OutputStream
l'héritage et l'implémentation d'interfaces
{public double readDouble();
public void writeDouble(double x);
}

Exemple :
6.Les références de type interface
interface Printable // propriété d'être imprimé • Il est possible de déclarer des références de type interface
{public void print();} afin de désigner des objets qui implémentent l'interface en
class MonStream implements DataStream, Printable question. Les objets désignés peuvent être de types différents
{
public void print() { …} • L'opérateur instanceof peut être utilisé pour savoir si un objet
public int read() { …} implémente une interface donnée
public void write(int n) { …}
public double readDouble(){ …}
public void writeDouble(double x) { …}
}

3
 18/12/2019

interface Comparer
7.Applications { public boolean inférieur(Object x, Object y); }
class TriGénérique
Le tri générique { public static void tri (Object [] T, Comparer op)
• L’exemple donné ci-après représente un tri générique. La { for (int i=0; i<T.length-1; i++)
méthode tri() de la classe TriGénérique permet d’ordonner un for (int j=i+1; j< T.length; j++)
tableau d’objets de type quelconque. La seule propriété exigée if (op.inférieur (T[j],T[i]))
est que les éléments soient comparables par la méthode {
inférieur (Object x, Object y) qui rend vrai si x est inférieur (en un Object x=T[i];
certain sens) à y. T[i]=T[j];
• Pour cela on utilise une interface Comparer qui définit le profil T[j]=x;
de la procédure inférieur. La méthode tri() reçoit en paramètre }
un objet comparateur op qui implémente cette interface. }
}

class Personne
• Pour trier n’importe quel type d’objet selon n’importe quel {
critère, il suffit d’implémenter l’interface Comparer au moyen public String nom;
d’une classe convenable et de passer en paramètre du tri une public int age, poids;
instance de cette classe. public Personne(String n, int a, int p)
{ nom=n; age=a; poids=p; }
• On se propose d’utiliser la classe TriGénérique pour ordonner }
des personnes. Une personne est caractérisée par un nom, un • Soit la population suivante :
âge et un poids. Personne [] peuple = new Personne[4];
peuple[0] = new Personne("toto", 25, 80);
peuple[1] = new Personne("tutu", 53, 65);
peuple[2] = new Personne("tata", 15, 47);
peuple[3] = new Personne("jojo", 12, 30);

4
 18/12/2019

• Solution :
• Questions :

class ComparerAge implements Comparer

– Définir la classe ComparerAge qui implémente l’interface
Comparer {
public boolean inférieur(Object x, Object y)
– Définir la classe ComparerPoids qui implémente l’interface {return((Personne)x).age<((Personne)y).age;}
Comparer }

– Définir la classe TestTriGénérique pour trier la population
sus-indiquée selon leurs ages puis selon leurs poids
(afficher les noms des personnes à l’issu de chaque tri)
class ComparerPoids implements Comparer
{
public boolean inf(Object x, Object y)
{return((Personne)x).poids<((Personne) y).poids;}
}

class TestTriGénérique
{ public static void main (String [] args)
{ Personne [] peuple = new Personne[4];
peuple[0] = new Personne("toto", 25, 80);
peuple[1] = new Personne("tutu", 53, 65);
peuple[2] = new Personne("tata", 15, 47);
peuple[3] = new Personne("jojo", 12, 30);
TriGénérique.tri(peuple, new ComparerAge() );
System.out.println("TRI SELON AGE");
for (int i=0; i<4; i++)
System.out.println(peuple[i].nom);
TriGénérique.tri(peuple, new ComparerPoids());
System.out.println("TRI SELON POIDS");
for (int i=0; i<4; i++)
System.out.println(peuple[i].nom);
}
}