Abstraction : masquer la complexité

Qu'est-ce que l'abstraction ? Définition et objectifs

L'abstraction est un autre principe fondamental de la programmation orientée objet (avec l'encapsulation, l'héritage et le polymorphisme).

L'abstraction consiste à masquer les détails d'implémentation complexes d'un objet et à n'exposer qu'une interface simple et de haut niveau à l'utilisateur de l'objet.

L'objectif de l'abstraction est de simplifier l'utilisation des objets en cachant les détails inutiles et en ne montrant que les informations essentielles.

Pensez à une voiture : vous n'avez pas besoin de savoir comment fonctionne le moteur en détail pour conduire la voiture. Vous avez une interface simple (volant, pédales, levier de vitesse) qui vous permet de contrôler la voiture sans vous soucier de la complexité interne.

En programmation, l'abstraction permet de :

• Réduire la complexité : L'utilisateur d'un objet n'a pas besoin de connaître tous les détails de son fonctionnement interne.
• Faciliter la maintenance : Vous pouvez modifier l'implémentation interne d'un objet sans affecter le code qui utilise cet objet, tant que l'interface publique reste la même.
• Favoriser la réutilisabilité : Les objets abstraits peuvent être réutilisés dans différents contextes, car leur utilisation est indépendante de leur implémentation.

Abstraction en Python : interface publique vs. implémentation interne

En Python, l'abstraction est réalisée en définissant une interface publique pour une classe, composée des méthodes et des attributs que les utilisateurs de la classe sont censés utiliser.

L'implémentation interne de la classe (les détails de la façon dont les méthodes fonctionnent, les attributs "protégés" ou "privés") est masquée à l'utilisateur.

Exemple :

Reprenons l'exemple de la classe `Cercle`, et imaginons que l'on souhaite utiliser une formule plus précise que `3.14159` pour le calcul de l'aire et la circonférence :

import math

class Cercle:
    def __init__(self, rayon):
        self._rayon = rayon  # Attribut "protégé"

    @property
    def rayon(self):
        return self._rayon

    @rayon.setter
    def rayon(self, valeur):
        if valeur < 0:
            raise ValueError("Le rayon ne peut pas être négatif.")
        self._rayon = valeur
        
    def aire(self):
      return math.pi * self._rayon * self._rayon
      
    def circonference(self):
      return 2 * math.pi * self._rayon

Dans cet exemple :

• L'interface publique de la classe `Cercle` est constituée des méthodes `rayon` (accesseur et mutateur), `aire` et `circonference`.
• L'attribut `_rayon` et l'utilisation de `math.pi` sont des détails d'implémentation internes.

L'utilisateur de la classe `Cercle` n'a pas besoin de savoir que le rayon est stocké dans un attribut nommé `_rayon`, ni que `math.pi` est utilisé pour les calculs. Il peut utiliser la classe `Cercle` simplement en appelant les méthodes `rayon`, `aire` et `circonference`.

Nous avons *masqué la complexité* des calculs et de la gestion de l'attribut `rayon`.

Comment réaliser l'abstraction en Python ?

Voici quelques techniques pour réaliser l'abstraction en Python :

• Utiliser des noms descriptifs : Choisissez des noms de classes, de méthodes et d'attributs qui décrivent clairement leur rôle et leur utilisation.
• Documenter l'interface publique : Utilisez des docstrings pour expliquer comment utiliser les classes et les méthodes, sans entrer dans les détails d'implémentation.
• Utiliser les conventions de nommage : Utilisez le simple soulignement (`_`) pour les attributs et méthodes "protégés" (destinés à un usage interne), et le double soulignement (`__`) pour les attributs et méthodes "privés" (pour éviter les conflits de noms).
• Utiliser des propriétés (`@property`) : Pour contrôler l'accès aux attributs et masquer les détails de leur gestion.
• Définir des interfaces claires : Concevez vos classes de manière à ce qu'elles aient une interface publique simple et cohérente, qui cache la complexité interne.
• (Plus avancé) Utiliser des classes abstraites (ABC) : Pour définir des interfaces abstraites qui doivent être implémentées par des sous-classes (voir le chapitre sur l'héritage).

Abstraction et encapsulation : deux concepts liés

L'abstraction et l'encapsulation sont deux concepts étroitement liés, mais distincts.

• Encapsulation : Regrouper les données (attributs) et les méthodes qui manipulent ces données au sein d'une classe, et contrôler l'accès à ces données depuis l'extérieur.
• Abstraction : Masquer les détails d'implémentation complexes et exposer une interface simple et de haut niveau.

On peut dire que l'encapsulation est un moyen d'atteindre l'abstraction. En encapsulant les données et en contrôlant leur accès, vous pouvez masquer les détails d'implémentation et fournir une interface plus abstraite.

L'abstraction est un concept plus général. Elle ne concerne pas seulement la manière dont les données sont stockées et manipulées, mais aussi la manière dont les fonctionnalités sont présentées à l'utilisateur.

L'encapsulation se concentre plus sur la *protection* des données, tandis que l'abstraction se concentre plus sur la *simplification* de l'utilisation.