Abstraction

Nous arrivons au dernier, mais très important, principe de la POO : l’abstraction. Le mot « abstraction » semble assez abstrait, et en résumé, ce principe indique que nous devons dépendre de l’abstraction plutôt que d’une implémentation spécifique. Cependant, cela peut sembler complexe pour l’instant. Commençons par examiner la définition :

Par exemple, nous avons une classe appelée Person,, et de nombreuses classes différentes en dérivent. Person possède divers champs et méthodes communs à toutes les classes. Cependant, lorsqu’il s’agit d’une classe comme BasketballPlayer,, la caractéristique height devient cruciale, tandis que pour une classe comme Driver, height est hors de propos et sans importance. C’est là que l’abstraction intervient. En héritant d’une abstraction, nous pouvons rendre le paramètre height optionnel, ce qui évite de l’utiliser là où il n’est pas nécessaire.

Cela peut sembler complexe, passons donc à un exemple :

La classe Car ne représente rien de spécifique. Il n’existe pas simplement une Car ; il y a des berlines, des camions, des tracteurs. Ainsi, nous dépendons de l’abstraction appelée Car. Pour simplifier davantage : Car est un modèle sur lequel nous créons des classes de voitures spécifiques.

Attention à la syntaxe :

public abstract class className{ }.

Ceci est la syntaxe pour déclarer une classe abstraite. Notez également la syntaxe pour déclarer une méthode abstraite :

public abstract returnValue methodName();

Une méthode abstraite n’a pas de corps ; c’est sa caractéristique principale. Les sous-classes d’une classe abstraite vont surcharger cette méthode abstraite pour définir leur propre implémentation, en utilisant le polymorphisme.

Examinons de plus près ce qu’est une classe abstraite :

Notez que nous ne pouvons pas créer un objet à partir d’une classe abstraite ; cela entraînera une erreur :

Les classes abstraites nous libèrent de la gestion exclusive des « objets » ; elles nous fournissent un état de base et un comportement de base. Prenons l'exemple des voitures : chaque voiture doit avoir un modèle, une année de production, une vitesse maximale et une couleur. Elles doivent également pouvoir se déplacer et s'arrêter. C'est tout ; à partir de là, vous concevrez vos classes spécifiques en vous basant sur ce modèle abstrait.

Règles pour créer une classe abstraite

1. Une classe abstraite est une classe qui contient au moins une méthode abstraite. Vous pouvez créer une classe abstraite sans aucune méthode abstraite, mais cela n'aurait alors aucune utilité. Vous ne pourrez pas instancier d'objets à partir d'une classe abstraite ;
2. Les méthodes abstraites ne peuvent exister qu'à l'intérieur d'une classe abstraite ; il est impossible de créer des méthodes abstraites en dehors d'une classe abstraite ;
3. Les méthodes d'une classe abstraite peuvent être soit des méthodes abstraites, soit des méthodes avec implémentation ;
4. Une classe qui hérite d'une classe abstraite doit redéfinir toutes les méthodes abstraites ;
5. Vous pouvez hériter d'au maximum une seule classe (abstraite ou non abstraite) ;
6. Une classe abstraite doit représenter les propriétés et comportements communs de ses classes dérivées. Nous aborderons ce point plus en détail lors de l'étude des principes SOLID.

Prenons un exemple pour comprendre comment les sous-classes doivent redéfinir les méthodes abstraites en héritant d'une classe abstraite, en utilisant l'exemple de la classe enfant Truck :

Voici le code de la capture d'écran, réécrit pour une meilleure lisibilité et clarté :

Examinons de plus près ce qui est décrit ci-dessus en détail :

• Première diapositive : Création d'une sous-classe Truck qui hérite de la classe abstraite Car. L'EDI indique qu'il est nécessaire d'implémenter les méthodes requises ;

• Deuxième diapositive : Redéfinition des méthodes nécessaires. Par exemple, il sera indiqué que le Truck commence à se déplacer puis s'arrête ;

• Troisième diapositive : Création d'un objet dans la méthode main. Attention à la syntaxe utilisée : Car name = new Truck();. L'objet est créé à travers l'abstraction et se termine par une implémentation spécifique. Ceci est appelé composition. Ensuite, les valeurs sont attribuées aux champs selon les besoins et les méthodes redéfinies sont appelées.

Voilà ! Si tout est compris, l'utilisation d'une classe abstraite est acquise !

Résumé

L'abstraction est probablement le principe le plus difficile à comprendre en POO, et il est fort probable que tout ne soit pas encore assimilé à ce stade. Mais il ne faut pas penser être seul dans ce cas. L'abstraction est un concept qui s'avère difficile à appréhender pour la plupart des développeurs au début. Avec le temps, la compréhension de l'utilisation efficace de l'abstraction et des classes abstraites s'améliorera. L'abstraction est un principe fondamental car elle permet de rendre les programmes extensibles et très flexibles.