Héritage et polymorphisme 🧬

Tu as déjà remarqué que tous les chiens sont des animaux ? Un chien mange, dort, respire — comme tous les animaux. Mais en plus, il aboie et rapporte la balle. C'est exactement ça, l'héritage en POO !

1. L'héritage : réutiliser sans copier 🧬

🧬 Principe : La classe enfant hérite de TOUT ce que la classe parent a (attributs + méthodes), et peut en ajouter ou en modifier.

Exécution pas à pas
pseudo
1/38
▶️CLASSE Animal
CLASSE AnimalLe programme exécute cette action, puis passe à la suivante.
Le programme exécute cette instruction, puis passe à la suivante.


class Animal:
    def __init__(self, nom):
        self.nom = nom
        self.energie = 100

    def manger(self):
        self.energie += 10
        return f"{self.nom} mange"

    def dormir(self):
        self.energie = 100
        return f"{self.nom} dort"

    def parler(self):
        return "..."

class Chien(Animal):  # Chien hérite de Animal
    def parler(self):  # Redéfinition (polymorphisme)
        return "Wouf !"

    def rapporter(self, objet):  # Nouvelle méthode
        return f"{self.nom} rapporte {objet}"

class Chat(Animal):   # Chat hérite aussi de Animal
    def parler(self):
        return "Miaou !"

    def griffer(self):
        return f"{self.nom} griffe"

2. Utilisation : le polymorphisme en action 🎭

Exécution pas à pas
pseudo
1/16
▶️' On crée des animaux
' On crée des animauxLe programme exécute cette action, puis passe à la suivante.
Le programme exécute cette instruction, puis passe à la suivante.


medor = Chien("Médor")
minou = Chat("Minou")

# Méthodes héritées
print(medor.manger())     # Médor mange
print(minou.dormir())     # Minou dort

# Méthodes redéfinies (polymorphisme)
print(medor.parler())     # Wouf !
print(minou.parler())     # Miaou !

# Méthodes spécifiques
print(medor.rapporter("balle"))  # Médor rapporte balle
print(minou.griffer())           # Minou griffe

3. Le polymorphisme en image 🖼️

💡 Le polymorphisme : MÊME appel (.parler()), mais chaque animal répond à SA façon. C'est le programme qui appelle, c'est l'objet qui décide comment réagir !

4. super() : appeler le parent 📞

Parfois, l'enfant veut utiliser le constructeur du parent et y ajouter des choses :

Exécution pas à pas
pseudo
1/13
▶️CLASSE ChienGuide HÉRITE DE Chien
CLASSE ChienGuide HÉRITE DE ChienLe programme exécute cette action, puis passe à la suivante.
Le programme exécute cette instruction, puis passe à la suivante.


class ChienGuide(Chien):
    def __init__(self, nom, maitre):
        super().__init__(nom)  # Appel du constructeur parent
        self.maitre = maitre

    def guider(self):
        return f"{self.nom} guide {self.maitre}"

guide = ChienGuide("Rocky", "Alice")
print(guide.guider())       # Rocky guide Alice
print(guide.parler())       # Wouf ! (hérité de Chien)
print(guide.manger())       # Rocky mange (hérité de Animal)

5. Héritage multiple 🎯

Une classe peut hériter de plusieurs parents à la fois :


class A:
    def methode(self):
        return "A"

class B:
    def methode(self):
        return "B"

class C(A, B):  # Héritage multiple
    pass

print(C().methode())  # "A" (l'ordre dans la déclaration compte)

Schéma récapitulatif 📊

💡 L'héritage est un outil puissant, mais n'en abuse pas : "Préfère la composition à l'héritage" (on verra ça dans la prochaine leçon !).

Exécution pas à pas

0/5

État de la mémoire

2 variables

Variable

Valeur

Type

Addr.

médor.type

Chien

class

0x2100

médor.méthodes

manger,dormir,aboyer

vtable

0x2108

Aucune variable active

médor.type0x2100

Chien

class

médor.méthodes0x2108

manger,dormir,aboyer

vtable

⚡ Simulateur — Héritage et polymorphisme

Étape 1/10

📝 Pseudo-code

1CLASSE Animal # ← classe de base

2 nom : texte

3 énergie : entier = 100

4 CONSTRUCTEUR(nom)

5 self.nom ← nom

6 self.énergie ← 100

7 FIN CONSTRUCTEUR

8 FONCTION parler() # ← défaut : silencieux

9 RETOURNER '...'

10 FIN FONCTION

11 FONCTION manger() # ← augmente l'énergie

12 self.énergie ← self.énergie + 10

13 RETOURNER self.nom + ' mange'

14 FIN FONCTION

15FIN CLASSE

17CLASSE Chien HÉRITE DE Animal # 🧬 Chien EST-UN Animal

18 FONCTION parler() # ⬅ redéfinit parler()

19 RETOURNER 'Wouf !'

20 FIN FONCTION

21FIN CLASSE

23CLASSE Chat HÉRITE DE Animal # 🧬 Chat EST-UN Animal

24 FONCTION parler() # ⬅ redéfinit aussi

25 RETOURNER 'Miaou !'

26 FIN FONCTION

27FIN CLASSE

29médor ← Chien('Médor') # ⬅ créer un Chien

30minou ← Chat('Minou') # ⬅ créer un Chat

31afficher(médor.parler()) # ⬅ polymorphisme !

32afficher(minou.parler()) # ⬅ MÊME appel, DIFFÉRENT

33afficher(médor.manger()) # ⬅ méthode héritée

🧬 Arbre d'héritage

Animal

💡 Héritage

Classe enfant reçoit tout du parent
Peut redéfinir des méthodes (override)
Peut ajouter ses propres méthodes
Polymorphisme : même appel, comportement différent

Classe de base Animal. Tous les animaux ont un nom, de l'énergie, et peuvent parler (par défaut: '...').