Approches à l’héritage

- Approche ascendante : Regrouper à un niveau supérieur ce qui est commun au niveau

inférieur.

- Approche descendante : Réutiliser, sans avoir à réécrire, tout ce qui a déjà été fait au
niveau supérieur et traiter ce qui est particulier à ce niveau.

Approche ascendante :

- Utilisée lors de l’analyse d’une hiérarchie d’héritage. On regroupe dans une classe ce
qui est commun à plusieurs classes. Dans la classe Employé, on regroupe les
caractéristiques (attributs et comportements) communes aux Salariés et aux Bénévoles.

Approche descendante :

- Réutilisation : La classe de base étant définie, on peut la reprendre intégralement pour

construire la classe dérivée. Par exemple, pour une nouvelle version d’un jeu vidéo, on
peut définir un nouveau type de personnage en reprenant intégralement un type existant
(en dérivant la classe) et en lui ajoutant de nouvelles particularités ainsi que les
traitements associés à ces particularités.

Classes et méthodes finales

Une méthode déclarée finale ne peut être redéfinie dans une classe dérivée.

Une classe déclarée finale ne peut plus être dérivée (Ex. : String)

Classes abstraites
Utilité

- Placer dans une classe abstraite toutes les attributs communs aux descendants ainsi que
les méthodes effectuant les traitements relatifs à ces attributs et déclarer les méthodes
fournissant les services souhaités par les descendants mais dont on ne peut définir un
traitement commun pour ces descendants.

- Sert comme classe de base pour une dérivation.

- Ne permet pas l'instanciation d’objets de cette classe.

IFT 1170, été 2009 Chapitre 9 : Classes abstraites et Interfaces.

M. Lokbani et M. Reid 140
- peut contenir des méthodes et des champs (qui peuvent être hérités) et une ou plusieurs
méthodes abstraites.

- une méthode abstraite est une méthode dont la signature et le type de la valeur de retour
sont fournis dans la classe et rien d'autre (pas le corps de la méthode i.e. définition).

Syntaxe

abstract class A { // etc.}

Particularités

- une classe ayant une méthode abstraite est par défaut abstraite. Donc pas besoin de
"abstract" à ce stade.

- doivent être déclarées "public" sinon pas d'héritage!

- nom d'argument muet doit figurer même s'il est sans intérêt!

- classe dérivée d'une classe abstraite n'est pas obligée de redéfinir toutes les méthodes
abstraites. Elle peut même n'en définir aucune. Si c'est le cas, elle reste abstraite.

- classe dérivée d'une classe non abstraite peut être déclarée abstraite.

Interfaces
C'est une classe abstraite particulière:

- Toutes les méthodes y sont abstraites.

- Ne possède aucun attribut, uniquement des constantes.

Utilité

- Permet de déclarer, sans les implémenter, un ensemble de comportements.

- Permet d'utiliser une sorte d'héritage multiple, même si cette notion est inexistante en
java: Une classe dérivée ne peut hériter que d'une seule classe de base (peut être
abstraite), mais elle peut implémenter plusieurs interfaces.

- Permet d’imposer un comportement semblable à des objets très différents, permettant

ainsi d’écrire des solutions générales, utilisant ces comportements, qui vont s’adapter
aux différents objets.

IFT 1170, été 2009 Chapitre 9 : Classes abstraites et Interfaces.

M. Lokbani et M. Reid 141
Syntaxe

public interface nom_interface { // etc.}

Implémentation

public interface I {
void f(int n);
void g();
}

class A implements I {

// A doit redéfinir les méthodes f & g prévues dans l'interface

}

- Les méthodes sont, par défaut, abstraites, il est inutile d’utiliser abstract dans leurs
déclarations.

- On ne peut pas différer l'implémentation.

- Une même classe peut implémenter plusieurs interfaces.

- On pourra utiliser des variables de type interface, mais on ne peut pas instancier ces
variables à des interfaces. On peut par contre utiliser le polymorphisme pour les affecter à
des objets implémentant l'interface.

Par exemple :
I unObjet = new A(); //Est valide
I unObjet = new I(); // N’est pas valide

- Interface et classe dérivée sont des notions indépendantes de l'héritage. Une classe
dérivée peut implémenter une ou plusieurs interfaces.

- Une constante déclarée dans une interface est vue comme une variable static final. On
ne peut pas donc modifier sa valeur. Elle est accessible de partout ou dans le paquetage
(si l'interface n'est pas public).

- La dérivation d'une interface: une interface peut dériver d'une autre en utilisant extends.
En réalité, l'opération a simplement permis de concaténer les déclarations. Les droits
d'accès ne sont pas pris en compte ce qui n'est pas le cas lors des héritages des classes.

IFT 1170, été 2009 Chapitre 9 : Classes abstraites et Interfaces.

M. Lokbani et M. Reid 142