Chapitre 6 : les classes abstraites et

les interfaces

Matière: Programmation Orientée Objets

Enseignante: Meriem AZAIEZ
Filière: 3ère année mécatronique

AU 2016 - 2017
 Définition : classes abstraites

 Une classe abstraite est une classe qui ne permet pas d’instancier des
objets, elle ne peut servir que de classe mère pour une dérivation.

 Dans une classe abstraite, on peut trouver des attributs et des méthodes,
dont héritera toute classe dérivée, et on peut trouver des méthodes «
abstraites ».

 Syntaxe:

abstract class NomMaClasse { … }

2
Meriem AZAIEZ-Programmation Orientée Objets
 Définition : méthodes abstraites

 Une méthode abstraite fournit uniquement la signature et le type de

retour sans implémentation (sans spécifier le corps de la méthode).

 Syntaxe:

[visibilité] abstract typeRetour nomMethode(arguments);

 Une méthode abstraite doit être absolument redéfinie dans une sous classe
pour pouvoir être utilisée.

 Une méthode abstraite ne peut pas être déclarée static, private ou final.
 Car elle est destinée à être redéfinie dans une classe dérivée.

3
Meriem AZAIEZ-Programmation Orientée Objets
 Règles des classes abstraites

 Une classe qui définit au moins une méthode abstraite doit être
obligatoirement déclarée abstraite.

 Une classe dérivée d’une classe non abstraite peut être déclarée abstraite.

 Une classe dérivée d’une classe abstraite n’est pas obligée de redéfinir
toutes les méthodes abstraites, elle peut ne redéfinir aucune, mais elle
reste abstraite tant qu’il y a encore des méthodes abstraites non
implémentées.

 On ne peut pas instancier une classe abstraite car au moins une de ses
méthodes n’a pas d’implémentation. Mais on peut:
 Déclarer des références du type de la classe abstraite.
 Créer un tableau des références du type de la classe abstraite.
4
Meriem AZAIEZ-Programmation Orientée Objets
 Règles des classes abstraites
abstract class A {
public void f() {…} //f est définie dans A
public abstract void g(int n); //g est une méthode
abstraite elle n’est pas définie dans A
}
class B extends A {
public void g(int n) {
//implémentation de g
}
}

A a; //On peut déclarer une référence sur un objet de

type A ou dérivé
a = new A(); //Erreur pas d’instanciation d’objets d’une
classe abstraite
a = new B(); //Juste car B n’est pas une classe
abstraite
A[] b = new A[3]; //On peut créer un tableau de type A
5
Meriem AZAIEZ-Programmation Orientée Objets
 Intérêt des classes abstraites

 Les classes abstraites constituent une sorte de contrat.

 Elles garantit que certaines méthodes seront disponibles et complètes dans
toutes ses descendantes concrètes.

 Elles sont utiles lorsque:

 On ne connaît pas le comportement d’une opération commune à plusieurs
sous-classes.
 La méthode n’a pas besoin à être définie dans la classe mère, mais on la
déclare juste pour pouvoir utiliser le polymorphisme sur les objets.

6
Meriem AZAIEZ-Programmation Orientée Objets
 Intérêt des classes abstraites

class A { }
class B extends A {
public void m() { … }
} A a = new B();
a.m(); //Erreur car m()
n’est pas définie dans A

abstract class A {
public abstract void m();
}
class B extends A {
public void m() { … }
} A a = new B();
a.m(); //Juste
7
Meriem AZAIEZ-Programmation Orientée Objets
 Exemple 1

Forme

Cercle Rectangle

 Les méthodes de calcul de surface et de périmètre des formes

géométriques n’ont de « sens » que pour les sous-classes Cercle et
Rectangle.
 On peut déclarer des méthodes « abstraite » dans la classe mère « Forme »
et on les implémente dans les sous-classes « Cercle » et « Rectangle ».
8
Meriem AZAIEZ-Programmation Orientée Objets
 Les interfaces

 Une interface est une classe abstraite ne contenant que des méthodes
abstraites et/ou des attributs constants.

 Syntaxe:

[visibilité] interface NomInterface {}

 Une interface est un modèle pour une classe.

 Elle définit la signature des méthodes qui doivent être implémentées dans les
classes qui respectent ce modèle.

Ne pas confondre avec les interfaces graphiques (Swing) !

9
Meriem AZAIEZ-Programmation Orientée Objets
 Les interfaces
interface I {
public static final int CONST = 2;
public abstract void f(int n);
void g();
}

 Les méthodes d’une interface sont toutes abstraites et publiques, donc, il

n’est pas obligatoire de le mentionner.
 Même si on a mis la visibilité par défaut dans l'interface, le compilateur y ajoute
public abstract.
 Les attributs d’une interfaces sont constantes, statiques et publiques.
 Implicitement ou explicitement.
 L'accès aux attributs des interfaces:
 « NomInterface.nomAttribut », si non.
 Directement « nomAttribut », quand on est dans une classe qui implémente
l’interface.
10
Meriem AZAIEZ-Programmation Orientée Objets
 Implémentation d’une interface

 Lorsqu’on définit une classe, on peut préciser qu’elle implémente une ou

plusieurs interfaces en utilisant le mot clé « implements ».
class NomClasse implements Interface1,Interface2, … { … }

 Si une classe hérite d’une autre classe elle peut également implémenter
une ou plusieurs interfaces.
 Elle peut même ré-implémenter une interface déjà implémentée par la classe
mère.
class A implements Inter1 { … }
class B extends A implements Inter1,Inter2 { … }

 C’est une solution partielle pour l’héritage multiple, interdit en Java, avec
l’obligation d’implémenter les méthodes correspondantes.
11
Meriem AZAIEZ-Programmation Orientée Objets
 Implémentation d’une interface

 Soit une interface I et une classe A qui l’implémente :

public class A implements I { … }

 La classe « A » peut ne pas implémenter toutes les méthodes de l’interface

«I»
 Implémentation partielle de l’interface.
 La classe « A » doit être déclarée abstract.
 Les méthodes manquantes seront implémentées par les classes filles de « A ».

12
Meriem AZAIEZ-Programmation Orientée Objets
 Exemple 2

 On souhaite:
 Implémenter une méthode « afficher » pour les classes filles.
 Cette méthode n’est pas définie dans la classe « Type ».

Type

VEntier VFlottant VBooléen

13
Meriem AZAIEZ-Programmation Orientée Objets
 Règles des interfaces

 Les interfaces servent à faire du polymorphisme avec des objets dont les
classes n’appartiennent pas à la même hiérarchie d’héritage.

 Une classe peut implémenter plusieurs interfaces, alors qu’elle ne peut

dériver que d’une seule classe (abstraite).

 Toute classe concrète qui implémente l’interface doit implémenter toutes

les méthodes définies par l’interface.

 Une interface peut être implémentée par plusieurs classes.

14
Meriem AZAIEZ-Programmation Orientée Objets
 Règles des interfaces

 Les interfaces ne peuvent pas être instanciées.

 Elles n’ont pas de constructeur.
 On ne peut pas créer des objets de type interface.

 On peut définir des références de type interface à une instance d’une

classe qui implémente cette interface.

interface I { … }
class A implements I { … }

I i1; //Juste
I i2 = new I(); //Erreur
I i3 = new A(); //Juste

15
Meriem AZAIEZ-Programmation Orientée Objets
 Règles des interfaces

 Les interfaces peuvent se dériver.

 Une interface peut hériter d’une ou de plusieurs autres interfaces mais elle ne
peut pas hériter d’une classe.

 Les méthodes de l’interface mère sont reprises dans les interfaces filles.
 Toute classe qui implémente l’interface fille doit donner une implémentation
à toutes les méthodes mêmes celle héritées.

16
Meriem AZAIEZ-Programmation Orientée Objets
 Règles des interfaces
interface I1 { interface I2 {
void m1(); void m2();
static final int v1 = 10; static final int v2 = 20;
} }

interface I extends I1, I2 { interface I extends I1, I2 {

void m3(); void m1();
} static final int v1 = 10;
void m2();
static final int v2 = 20;
void m3();
class A implements I { }
public void m1() {…}
public void m2() {…}
public void m3() {…}
}

17
Meriem AZAIEZ-Programmation Orientée Objets
 Conflits des noms
interface I1 { interface I2 {
void m1(); void m1();
void m2(); int m2();
void m3(int x); void m3();
} }

class A implements I1, I2 { … }

 Pour les méthodes m1 :

 La classe « A » doit implémenter la méthode m1() qui existe dans les 2
interfaces une seule fois.
 Pour les méthodes m2 :
 Erreur car void m2() et int m2() ne peuvent pas coexister au sein de la même
classe.
 Pour les méthodes m3 :
 La classe « A » doit implémenter les deux méthodes m3() surchargées.
18
Meriem AZAIEZ-Programmation Orientée Objets
 Récapitulatif

 Les classes :
 Sont complètement implémentées.
 Une seule autre classe peut en hériter.
 Les classes abstraites :
 Sont partiellement implémentées.
 Une autre classe non abstraite peut en hériter mais doit donner une
implémentation à toutes les méthodes abstraites.
 Une autre classe abstraite peut en hériter sans forcément donner une
implémentation à toutes les méthodes abstraites.
 Ne peuvent pas être instanciées mais peuvent fournir un constructeur.
 Les interfaces :
 Ne contiennent pas de constructeur.
 Ne sont pas implémentées.
 Toute classe qui implémente une ou plusieurs interfaces doit implémenter
toutes leurs méthodes (abstraites).
19
Meriem AZAIEZ-Programmation Orientée Objets