Programmation orientée objet

1. Du procédural à l'objet

En programmation procédurale, données et traitements sont séparés. La programmation orientée objet (POO) les réunit dans une même entité : l'objet. Cela améliore la lisibilité, la réutilisabilité et la maintenance des programmes volumineux.

• Classe : modèle décrivant une catégorie d'objets (le plan de construction).
• Objet / instance : réalisation concrète d'une classe.
• Attribut : donnée caractérisant un objet.
• Méthode : fonction définie dans la classe, agissant sur l'objet.
• Constructeur : méthode __init__ appelée à la création, qui initialise les attributs.

2. Écrire une classe en Python

class Livre:
    """Représente un livre d'une bibliothèque."""

    def __init__(self, titre, auteur, pages):
        self.titre = titre          # attribut d'instance
        self.auteur = auteur
        self.pages = pages
        self.emprunte = False

    def emprunter(self):
        if self.emprunte:
            return False
        self.emprunte = True
        return True

    def rendre(self):
        self.emprunte = False

    def __repr__(self):
        return f"{self.titre} — {self.auteur} ({self.pages} p.)"

Utilisation :

l = Livre("L'Étranger", "Camus", 159)
print(l.emprunter())   # True
print(l.emprunter())   # False : déjà emprunté
print(l)               # L'Étranger — Camus (159 p.)

self désigne l'instance sur laquelle la méthode est appelée : l.emprunter() équivaut à Livre.emprunter(l).

3. Encapsulation

L'encapsulation consiste à protéger l'état interne d'un objet et à n'exposer qu'une interface. En Python, la convention _attribut signale un attribut privé, et l'on fournit des accesseurs (getters) et mutateurs (setters) :

class Compte:
    def __init__(self, solde=0):
        self._solde = solde

    @property
    def solde(self):
        return self._solde

    def deposer(self, montant):
        if montant <= 0:
            raise ValueError("Montant invalide")
        self._solde += montant

Intérêt : garantir un invariant (ici, un solde jamais modifié par une valeur négative) impossible à assurer si l'attribut était librement accessible.

4. Héritage et polymorphisme

class Document:
    def __init__(self, titre):
        self.titre = titre
    def description(self):
        return f"Document : {self.titre}"

class Bd(Document):                      # Bd hérite de Document
    def __init__(self, titre, dessinateur):
        super().__init__(titre)          # appel au constructeur parent
        self.dessinateur = dessinateur
    def description(self):               # redéfinition (override)
        return f"BD : {self.titre}, dessin de {self.dessinateur}"

for d in [Document("Rapport"), Bd("Astérix", "Uderzo")]:
    print(d.description())               # polymorphisme

• Héritage : la sous-classe récupère attributs et méthodes de la classe mère (relation « est-un »).
• Polymorphisme : un même appel description() produit un comportement différent selon le type réel de l'objet.
• Composition (relation « a-un ») : une Bibliotheque contient une liste de Livre ; on la préfère à l'héritage quand il n'y a pas de spécialisation.

5. Attributs de classe vs d'instance

class Eleve:
    effectif = 0                 # attribut de classe, partagé
    def __init__(self, nom):
        self.nom = nom           # attribut d'instance, propre
        Eleve.effectif += 1

6. Bonnes pratiques et pièges

• Une classe = une responsabilité claire.
• Ne pas oublier self en premier paramètre des méthodes (erreur TypeError: ... takes 1 positional argument).
• Les valeurs par défaut mutables sont dangereuses : def __init__(self, items=[]) partage la même liste entre instances ; écrire items=None puis self.items = items or [].
• Documenter chaque classe par une docstring et tester avec assert.

À retenir

Classe = données (attributs) + comportements (méthodes). Encapsulation protège les invariants, héritage factorise le code commun, polymorphisme permet de traiter uniformément des objets de types voisins.