CHAPITRE 6 :

LES CLASSES ABSTRAITES ET LES INTERFACES

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.

Exemple : Document : Livre, Revue, …

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 de définir un code réutilisable par les classes à
dériver.
2. Définition d'une classe abstraite en JAVA

Une classe abstraite est déclarée avec le mot clé abstract.

Exemple : abstract class Document {….}
Une classe abstraite ne peut jamais être instanciée par l'opérateur new.
On peut déclarer des références de type classe abstraite. La méthode abstraite est aussi
déclarée avec le mot clé abstract.
Exemple : abstract class ObjetGraphique
{…
abstract float surface ();
…
}.

Si une classe comporte une méthode abstraite elle doit être déclarée abstraite. Une classe
abstraite peut ne pas comporter de méthodes abstraites. Toute classe concrète dérivée à partir
d'une classe abstraite doit donner un code aux méthodes abstraites héritées, si non elle doit
être déclarée abstraite (l'abstraction continue). On ne peut pas combiner les modificateurs
abstract et final.

3. Les interfaces

Une interface est une forme particulière de classe. Une interface définit, généralement, des
propriétés abstraites. Le concept d'interface est proposé par le langage JAVA pour résoudre le
problème de l'héritage multiple. 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). Une interface est
définie d'une manière similaire à une classe mais en utilisant le mot clé interface.
Les interfaces ne sont pas instanciables.
La syntaxe de déclaration d'une interface est la suivante : interface NomInterface { … }.

Exemples : interface Edition

{void editer();}
interface Affichage
{

1
 int MIN = 0;
int MAX=100;
void afficher();
}

4. Interfaces et héritage

Une interface peut hériter d'une ou de plusieurs autres interfaces. Il s'agit d'une
extension de propriétés sous forme de méthodes abstraites et de constantes
statiques.
Exemple :
interface InputStream // propriété d'accepter des caractères
{ public int read(); }
interface OutputStream // propriété de fournir des caractères
{ public void write(int n); }
interface DataStream extends InputStream, OutputStream
{ public double readDouble();
public void writeDouble(double x);
}.

5. Implémentation d'une interface

Une classe peut implémenter plusieurs interfaces, c'est à dire avoir les même caractéristiques
(ou propriétés) définies au niveau de ces interfaces. Réciproquement, la même interface peut
être implémentée par plusieurs classes. L'implémentation est une forme d'héritage multiple. Il
est possible de combiner, lors de la définition d'une classe, l'héritage et l'implémentation
d'interfaces.

Exemple

interface Printable // propriété d'être imprimé

{ public void print(); }
class MonStream implements DataStream, Printable
{
public void print() { …}
public int read() { …}
public void write(int n) { …}
public double readDouble(){ …}
public void writeDouble(double x) { …}
}

6. Les références de type Interface

Il est possible de déclarer des références de type interface afin de désigner des objets qui
implémentent l'interface en question. Les objets désignés peuvent être de types différents.
L'opérateur instanceof peut être utilisé pour savoir si un objet implémente une interface
donnée.