{"id":76,"date":"2021-05-29T14:03:41","date_gmt":"2021-05-29T14:03:41","guid":{"rendered":"https:\/\/www.louismarchand.me\/?page_id=76"},"modified":"2021-05-29T14:23:16","modified_gmt":"2021-05-29T14:23:16","slug":"methodes-abstraites-et-classes-abstraites","status":"publish","type":"page","link":"https:\/\/www.louismarchand.me\/index.php\/methodes-abstraites-et-classes-abstraites\/","title":{"rendered":"M\u00e9thodes abstraites et classes abstraites"},"content":{"rendered":"

Introduction<\/h2>\n

L’h\u00e9ritage et le polymorphisme sont des m\u00e9canismes tr\u00e8s int\u00e9ressants qui permettent de bien repr\u00e9senter les objets r\u00e9els, de diminuer la complexit\u00e9 du code et qui permettent d’augmenter grandement la r\u00e9utilisation de code et la facilit\u00e9 de maintenance d’un logiciel. Par contre, dans tous ces m\u00e9canismes, il manque un \u00e9l\u00e9ment important.<\/p>\n

En effet, dans une m\u00eame cat\u00e9gorie d’objet, il est possible que tous les objets aient des m\u00e9caniques similaires communes, mais que leurs impl\u00e9mentations divergent plus ou moins l\u00e9g\u00e8rement d’un objet \u00e0 l’autre.<\/p>\n

Pour donner un exemple plus concret, on peut imaginer que tous les v\u00e9hicules ont la capacit\u00e9 de se d\u00e9placer; mais la m\u00e9canique qui permet ce d\u00e9placement est tr\u00e8s diff\u00e9rente si on observe un bateau \u00e0 voile ou une automobile.<\/p>\n

En objet, c’est ce que permettent de repr\u00e9senter les m\u00e9thodes abstraites.<\/p>\n

Les m\u00e9thodes abstraites<\/h2>\n

Il arrive que, lors du \u00ab\u00a0design\u00a0\u00bb d’une classe, il soit logique que tous les objets de ce type aient une certaine m\u00e9thode, mais que l’impl\u00e9mentation de cette m\u00e9thode puisse diff\u00e9rer en fonction des descendants de cette classe. Dans ce cas, il est n\u00e9cessaire de d\u00e9clarer cette m\u00e9thode dans la classe, sans fournir d’impl\u00e9mentation. La d\u00e9claration de cette m\u00e9thode est appel\u00e9e m\u00e9thode abstraite<\/strong>.<\/p>\n

Pour fournir un exemple, nous allons utiliser le \u00ab\u00a0design\u00a0\u00bb que nous avons d\u00e9velopp\u00e9 durant les th\u00e9ories pr\u00e9c\u00e9dentes:<\/p>\n

\"\"<\/p>\n

Ce \u00ab\u00a0desing\u00a0\u00bb est fonctionnel, mais n\u00e9cessite d’effectuer des tests de type ainsi que du \u00ab\u00a0cast\u00a0\u00bb de type pour lancer le cri (aboyer et miauler) des diff\u00e9rents animaux. Par exemple, voici le code que nous avons d\u00e9velopp\u00e9 \u00e0 ce sujet:<\/p>\n

\n
public<\/span> void<\/span> criAnimal<\/span>(<\/span>Animal<\/span> aAnimal<\/span>)<\/span> {<\/span>\n    if<\/span> (<\/span>aAnimal<\/span> instanceof<\/span> Chien<\/span>)<\/span> {<\/span>\n        ( (<\/span>Chien<\/span>)<\/span>aAnimal<\/span>).<\/span>aboyer<\/span>();<\/span>\n    }<\/span> else<\/span> if<\/span> (<\/span>aAnimal<\/span> instanceof<\/span> Chat<\/span>)<\/span> {<\/span>\n        ( (<\/span>Chat<\/span>)<\/span> aAnimal<\/span>).<\/span>miauler<\/span>();<\/span>\n    }<\/span>\n}<\/span>\n<\/pre>\n<\/div>\n
Le probl\u00e8me ici, c’est que chaque type enfant doit \u00eatre g\u00e9r\u00e9 individuellement; ce qui rend moins int\u00e9ressant le principe de polymorphisme. Il suffit d’imaginer qu’il y a 20 classes enfants de Animal diff\u00e9rentes pour voir que cette m\u00e9thode deviendra trop complexe. De plus, \u00e0 chaque fois qu’une nouvelle classe enfant de Animal est cr\u00e9\u00e9e, il faut modifier du code dans chaque client de la classe afin d’ajouter la gestion du nouvel enfant.<\/p>\n
Pour nous rapprocher de la solution, nous pourrions imaginer mettre toutes les m\u00e9thodes de cri d’animaux avec le m\u00eame nom. Comme ceci:<\/p>\n
\"\"<\/p>\n
L’objectif serait de pouvoir seulement faire ce code:<\/p>\n
\n
public<\/span> void<\/span> criAnimal<\/span>(<\/span>Animal<\/span> aAnimal<\/span>)<\/span> {<\/span>\n    aAnimal<\/span>.<\/span>cri<\/span>();<\/span>\n}<\/span>\n<\/pre>\n<\/div>\n
Par contre, ici, le code ne fonctionne pas parce que, m\u00eame si Chien et Chat ont une m\u00e9thode cri(), il n’est pas sp\u00e9cifi\u00e9 dans Animal que cette m\u00e9thode cri() existe. Puisque le compilateur consid\u00e8re que cette variable est de type Animal (et non Chien et Chat), il faut que la classe Animal contienne cette m\u00e9thode pour que le code ci-haut compile.<\/p>\n
Ainsi, pour pr\u00e9ciser au compilateur que la m\u00e9thode existera toujours, dans tous les enfants de Animal, je vais d\u00e9clarer la m\u00e9thode cri() dans Animal, mais sans pr\u00e9ciser d’impl\u00e9mentation. Les impl\u00e9mentations seront programm\u00e9es dans les enfants. Voici le code (qui n’est pas encore final) de ce que \u00e7a aura l’air.<\/p>\n
\n
\/**<\/span>\n * Repr\u00e9sente tous les sp\u00e9cimens animal.<\/span>\n * <\/span>\n * @author Louis Marchand (prog@tioui.com)<\/span>\n * @version 0.1, mercredi mar 10, 2021 16:58:57 EST<\/span>\n * <\/span>\n * Distribu\u00e9 sous licence MIT.<\/span>\n *\/<\/span>\n\npublic<\/span> class<\/span> Animal<\/span> {<\/span>\n\n   ...\n\n    public<\/span> abstract<\/span> void<\/span> cri<\/span>();<\/span>\n\n    ...\n\n}<\/span>\n<\/pre>\n<\/div>\n
On nomme cette ligne de code m\u00e9thode abstraite cri().<\/p>\n
Les classes abstraites<\/h2>\n
Un autre probl\u00e8me survient en regardant le code pr\u00e9c\u00e9dent. Ce qu’il faut lire, c’est que tous les enfants de la classe Animal devront<\/strong> impl\u00e9menter la m\u00e9thode cri(), sinon, la compilation \u00e9chouera. Par contre, qu’arrivera-t-il si je fais le code suivant:<\/p>\n
\n
Animal<\/span> lAnimal<\/span> =<\/span> new<\/span> Animal<\/span>(<\/span>\"Socrate\"<\/span>,<\/span> 3<\/span>);<\/span>\nlAnimal<\/span>.<\/span>cri<\/span>();<\/span>\n<\/pre>\n<\/div>\n
Jusqu’\u00e0 maintenant, je pouvais effectivement cr\u00e9er directement un objet de type Animal. Par contre, ici, si j’effectue ce code, il est \u00e0 se demander que donnera l’expression \u00ab\u00a0lAnimal.cri()\u00a0\u00bb puisque \u00ab\u00a0lAnimal\u00a0\u00bb n’est pas de type Chien ni de type Chat et qu’il n’y a aucune impl\u00e9mentation de la m\u00e9thode \u00ab\u00a0cri()\u00a0\u00bb dans la classe Animal.<\/p>\n
Puisque l’utilisation de m\u00e9thode abstraite rend la classe d’une certaine mani\u00e8re impossible \u00e0 instancier directement, nous allons utiliser un nouveau type de classe. Nous allons appeler ce type de classe classe abstraite<\/strong>. Voici les caract\u00e9ristiques importantes des classes abstraites:<\/p>\n