POLYMORPHISME - classes abstraites
Les classes abstraites permettent de créer des classes génériques expliquant certains comportements
sans les implémenter et fournissant une implémentation commune de certains autres comportements
pour l'héritage de classes. Les classes abstraites sont un outil intéressant pour le polymorphisme.
Vocabulaire et concepts :
• Une classe abstraite est une classe qui ne peut pas être instanciée.
• Une classe abstraite peut contenir des méthodes déjà implémentées.
• Une classe abstraite peut contenir des méthodes non implémentées.
• Une classe abstraite est héritable.
• On peut contsruire une hiérarchie de classes abstraites.
• Pour pouvoir construire un objet à partir d'une classe abstraite, il faut dériver une classe non
abstraite en une classe implémentant toutes les méthodes non implémentées.
Une méthode déclarée dans une classe, non implémentée dans cette classe, mais juste définie par la
déclaration de sa signature, est dénommée méthode abstraite.
Une méthode abstraite est une méthode à liaison dynamique n’ayant pas d’implémentation dans la
classe où elle est déclarée. L' implémentation d'une méthode abstraite est déléguée à une classe
dérivée.
Si vous voulez utiliser la notion de classe abstraite pour fournir un polymorphisme à un groupe de
classes, elles doivent toutes hériter de cette classe
Les classes abstraites peuvent également contenir des membres déjà implémentés. Dans cette
éventualité, une classe abstraite propose un certain nombre de fonctionnalités identiques pour tous
ses futurs descendants.(ceci n'est pas possible avec une interface).
Utilisation pratique des classes abstraites
• Utilisez une classe abstraite lorsque vous voulez :
o d'une part regrouper un ensemble de méthodes présentant des fonctionnalités
identiques,
o et aussi d'autre part vous souhaitez disposer de facilités dans la déclaration et
l'implémentation de nouvelles méthodes.
• Lorsque l'on élabore des composants réutilisables, les classes abstraites sont très utiles pour
anticiper les adjonctions ultérieures. Dans le cas de nouvelles versions, la classe abstraite de
base est aisément extensible, les logiciels écrit pour la version précédente de la classe
fonctionneront toujours avec les anciens membres.
POLYMORPHISME - Interfaces
• Les interfaces ressemblent aux classes abstraites sur un seul point : elles contiennent des
membres expliquant certains comportements sans les implémenter.
• Les classes abstraites et les interfaces se différencient principalement par le fait qu'une classe
peut implémenter un nombre quelconque d'interfaces, alors qu'une classe abstraite ne peut
hériter que d'une seule classe abstraite ou non.
Vocabulaire et concepts :
• Une interface est un contrat, elle peut contenir des propriétés, des méthodes et des
événements mais ne doit contenir aucun champ ou attribut.
• Une interface ne peut pas contenir des méthodes déjà implémentées.
• Une interface doit contenir des méthodes non implémentées.
• Une interface est héritable.
• On peut contsruire une hiérarchie d'interfaces.
• Pour pouvoir construire un objet à partir d'une interface, il faut définir une classe non abstraite
implémentant toutes les méthodes de l'interface.
Une classe peut implémenter plusieurs interfaces. Dans ce cas nous avons une excellente alternative à
l'héritage multiple.
Lorsque l'on crée une interface, on fournit un ensemble de définitions et de comportements qui ne
devraient plus être modifiés. Cette attitude de constance dans les définitions, protège les applications
écrites pour utiliser cette interface.
Les variables de types interface respectent les mêmes règles de transtypage que les variables de types
classe.
Les objets de type classe clA peuvent être transtypés et reférencés par des variables d'interface IntfA
dans la mesure où la classe clA implémente l’interface IntfA. (cf. polymorphisme d'objet)
Si vous voulez utiliser la notion d'interface pour fournir un polymorphisme à une famille de classes, elles
doivent toutes implémenter cette interface
Utilisation pratique des interfaces
Quelques conseils prodigués par des développeurs professionnels (microsoft, Borland) :
• Les interfaces bien conçues sont plutôt petites et indépendantes les unes des autres.
• Un trop grand nombre de fonctions rend l'interface peu maniable.
• Si une modification s'avère nécessaire, une nouvelle interface doit être créée.
• La décision de créer une fonctionnalité en tant qu'interface ou en tant que classe abstraite peut
parfois s'avérer difficile.
• Vous risquerez moins de faire fausse route en concevant des interfaces qu'en créant des
arborescences d'héritage très fournies.
• Si vous projetez de créer plusieurs versions de votre composant, optez pour une classe
abstraite.
• Si la fonctionnalité que vous créez peut-être utile à de nombreux objets différents, faites appel à
une interface.
• Si vous créez des fonctionnalités sous la forme de petits morceaux concis, faites appel aux
interfaces.
• L'utilisation d'interfaces permet d'envisager une conception qui sépare la manière d'utiliser une
classe de la manière dont elle est implémentée.
• Deux classes peuvent partager la même interface sans descendre nécessairement de la même
classe de base.
Lors de la conception d'applications, il est important de savoir quand utiliser une classe abstraite et
quand utiliser une interface. Bien que les classes abstraites et les interfaces semblent similaires à
certains égards, il existe des différences clés qui déterminent quel est le meilleur choix pour ce que
vous essayez d'accomplir.
Une classe abstraite vous permet de créer des fonctionnalités que les sous-classes
peuvent implémenter ou remplacer. Une interface ne vous permet que de définir
une fonctionnalité et non de la mettre en œuvre. Et tandis qu’une classe ne peut
hériter que d’une seule classe abstraite, elle peut tirer parti de plusieurs
interfaces.