L'héritage est l'un des concepts fondamentaux de la Programmation Orientée Objet (POO).
Il permet à une classe (appelée enfant ou sous-classe) d'hériter des attributs et des méthodes d'une autre classe (appelée parent ou super-classe).

Cela signifie que vous pouvez définir un comportement commun et des données dans une classe de base, puis créer des classes plus spécialisées qui réutilisent et personnalisent cette fonctionnalité — sans avoir à réécrire le même code.

Syntaxe de base pour l'héritage

En Python, l'héritage s'implémente en spécifiant le nom de la classe parente entre parenthèses après le nom de la classe enfant.

class ParentClass:
    # Attributs et méthodes de la classe parente

class ChildClass(ParentClass):
    # Attributs et méthodes de la classe enfant

Quand une classe enfant hérite d'une classe parente, elle obtient :

• Tous les attributs de la classe parente (variables liées à l'objet)
• Toutes les méthodes de la classe parente (fonctions liées à l'objet)
• Tout constructeur (__init__) que la classe parente peut avoir

Exemple : Animaux et Sons

Illustrons l'héritage avec quelque chose auquel tout le monde peut s'identifier — les animaux.
Nous commençons par une classe générale Animal qui définit ce que tous les animaux ont en commun, puis nous créons des types spécifiques d'animaux (Dog et Cat) qui partagent ces caractéristiques mais émettent des sons différents.

Voici la classe de base :

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sound(self):
        pass  # Chaque animal spécifique décidera de son propre son

La classe Animal contient :

• Une méthode __init__ qui initialise le name et l'age de chaque animal.
• Une méthode sound() qui ne fait rien pour l'instant (pass est juste un espace réservé). Nous la remplacerons dans chaque type d'animal par le son spécifique à l'espèce.

Créons maintenant deux classes d'animaux spécifiques :

class Dog(Animal):
    def sound(self):
        print("Woof woof !")

class Cat(Animal):
    def sound(self):
        print("Meow !")

Voici ce qui se passe :

• Dog et Cat héritent tous deux de Animal, ils obtiennent donc automatiquement les attributs name et age sans avoir à réécrire ce code.
• Chacun remplace la méthode sound() pour produire son propre son unique.

Création et utilisation des objets

dog = Dog("Rex", 2)
cat = Cat("Mimi", 3)

print(dog.name)  # Rex
dog.sound()      # Woof woof !

print(cat.name)  # Mimi
cat.sound()      # Meow !

Lorsque nous créons Dog("Rex", 2), voici les étapes :

1. Python appelle la méthode __init__ de la classe Animal (car Dog n'a pas la sienne).
2. Les valeurs name et age passées sont stockées dans cet objet.
3. Lorsque nous appelons dog.sound(), Python cherche une méthode sound() dans Dog en premier. Il trouve celle que nous avons écrite et l'exécute — affichant "Woof woof !".

La même logique s'applique à Cat, qui trouve et exécute sa propre méthode sound().

Cet exemple montre la magie de l'héritage :

• Nous écrivons une seule fois la configuration commune (__init__) dans la classe Animal.
• Chaque sous-classe (Dog, Cat) conserve les fonctionnalités partagées et ajoute son propre comportement unique.
• Le résultat est un code moins répétitif, une logique plus organisée, et un moyen plus simple de gérer des objets liés.

3. Comment cela fonctionne

• Structure partagée : La méthode __init__ de Animal s'exécute lors de la création d'un objet Dog ou Cat, car elles l'héritent automatiquement.
• Surcharge de méthode : Dog et Cat possèdent chacun leur propre méthode sound() qui remplace (override) le placeholder de Animal. Quand vous appelez sound() sur un Dog, Python utilise celle définie dans Dog, pas celle de Animal.

ASTUCE : Si une classe enfant ne remplace pas une méthode, elle utilise automatiquement celle de la classe parente.

Pourquoi utiliser l'héritage ?

L'héritage vous permet :

• D'éviter la répétition de code en plaçant la logique partagée dans une classe de base unique.
• De rendre votre code plus modulaire et lisible.
• De construire des classes spécialisées à partir d'un modèle général.

Exemple de pensée en héritage :

• Animal → modèle général avec name, age et une méthode sound().
• Dog → type spécifique d'animal avec son propre son.
• Cat → autre type d'animal avec un son différent.

Conclusion

L'héritage est un outil puissant en POO pour créer une hiérarchie de classes, en partant de concepts généraux vers des concepts plus spécialisés.

En Python, vous l'implémentez en :

1. Écrivant une classe parente avec des attributs et méthodes communs.
2. Créant des sous-classes qui listent le nom de la classe parente entre parenthèses.
3. Ajoutant ou remplaçant des méthodes dans les sous-classes selon les besoins.

Dans la prochaine leçon, nous approfondirons ce concept en explorant super() — une manière pour les sous-classes d'appeler et d'étendre le comportement de leurs classes parentes.