Après cette leçon, tu seras capable de :

• Redéfinir une méthode héritée tout en conservant son interface attendue.
• Appeler la même méthode sur des objets de sous-classes différentes.
• Utiliser super() lorsqu'une redéfinition doit étendre, plutôt que remplacer, le comportement parent.
• Choisir entre un appel polymorphique unique et des conditions spécifiques répétées sur les types.

L'héritage crée une relation entre les types. Le polymorphisme permet au code de manipuler différents objets à travers un nom de méthode partagé. Une sous-classe redéfinit (override) une méthode en définissant une méthode portant le même nom. Appeler obj.summary() utilise l'implémentation appartenant à cet objet.

C'est l'équivalent Python de la redéfinition de méthodes en Java ou C#, mais tu n'as pas besoin d'ajouter @Override pour que cela fonctionne. Conserve les mêmes paramètres attendus et le même comportement de retour afin que les appelants n'aient pas besoin de connaître la sous-classe concrète.

Utilise super().method() lorsque le parent effectue déjà un travail utile que tu souhaites préserver. Une boucle peut alors traiter différents objets à travers la même interface, au lieu de vérifier leurs types et de dupliquer des branches conditionnelles.

1. Redéfinir une méthode parente

Une sous-classe renvoie une étiquette spécialisée lorsque la même méthode est appelée.

class Device:
    def status(self):
        return "unknown"

class Router(Device):
    def status(self):
        return "online"

print(Device().status())
print(Router().status())

Sortie :

unknown
online

2. Un appel de méthode, différents objets

La boucle n'a pas besoin de connaître la sous-classe exacte de chaque élément.

class Alert:
    def level(self):
        return "general"

class WarningAlert(Alert):
    def level(self):
        return "warning"

class ErrorAlert(Alert):
    def level(self):
        return "error"

alerts = [WarningAlert(), ErrorAlert(), Alert()]
for alert in alerts:
    print(alert.level())

Sortie :

warning
error
general

3. Étendre le comportement du parent

super() réutilise le message de base avant d'ajouter les informations de la sous-classe.

class Build:
    def summary(self):
        return "Build complete"

class VerifiedBuild(Build):
    def summary(self):
        return f"{super().summary()} | tests passed"

print(VerifiedBuild().summary())

Sortie :

Build complete | tests passed

4. Renvoyer des résultats depuis une interface partagée

Chaque classe fournit une méthode label(), afin que l'appelant puisse les traiter de manière uniforme.

class Transport:
    def label(self):
        return "standard"

class ExpressTransport(Transport):
    def label(self):
        return "express"

def describe(transport):
    return f"Shipping: {transport.label()}"

print(describe(ExpressTransport()))

Sortie :

Shipping: express

1. Donner à la méthode enfant un nom différent et s'attendre à une redéfinition.
2. Remplacer une méthode parente lorsque l'exigence était d'étendre son message.
3. Renvoyer un type de valeur différent depuis une sous-classe par rapport à ce que l'appelant attend.
4. Écrire une chaîne de vérifications de types lorsque chaque objet peut fournir la même méthode.