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

• Déclarer une sous-classe qui hérite du comportement d'une classe parente.
• Utiliser super().__init__(...) pour initialiser l'état d'instance hérité avant d'ajouter de nouveaux attributs.
• Étendre une méthode d'instance parente avec super().method(...) au lieu de copier sa logique.
• Reconnaître quand l'état ou les méthodes hérités doivent être préservés tout en personnalisant une sous-classe.

L'héritage permet à une classe de réutiliser le comportement d'une autre. Indique la classe parente entre parenthèses :

class Job:
    pass

class SpecialJob(Job):
    pass

Une sous-classe hérite des méthodes et attributs accessibles de son parent. Elle peut également définir ses propres attributs et méthodes. Lorsque la sous-classe définit un __init__, l'initialiseur du parent n'est pas automatiquement appelé. Appelle super().__init__(...) pour établir les attributs du parent avant d'en ajouter de nouveaux.

L'assistant super() permet également à une méthode d'instance qui redéfinit un comportement d'appeler l'implémentation du parent. Cela évite de dupliquer un comportement de base fonctionnel. La prochaine leçon portera en détail sur la redéfinition de méthodes et le polymorphisme ; pour l'instant, n'utilise une redéfinition que lorsqu'elle doit étendre ce que le parent fait déjà.

1. Réutiliser une méthode héritée

Une sous-classe peut appeler une méthode parente même lorsqu'elle ne définit pas elle-même cette méthode.

class Device:
    def __init__(self, identifier):
        self.identifier = identifier

    def label(self):
        return f"Device {self.identifier}"

class Laptop(Device):
    pass

print(Laptop("A14").label())

Sortie :

Device A14

Laptop a hérité de la méthode label() de Device.

2. Initialiser les attributs hérités et nouveaux

Utilise super().__init__ pour conserver la configuration du parent intacte.

class Account:
    def __init__(self, owner):
        self.owner = owner

class PremiumAccount(Account):
    def __init__(self, owner, credits):
        super().__init__(owner)
        self.credits = credits

print(f"{PremiumAccount('Noor', 50).owner}: premium")

Sortie :

Noor: premium

Le parent crée owner ; l'enfant ajoute credits.

3. Étendre une méthode avec super()

L'enfant peut réutiliser le résultat d'un parent et y ajouter ses propres informations.

class Message:
    def __init__(self, text):
        self.text = text

    def summary(self):
        return self.text

class UrgentMessage(Message):
    def summary(self):
        return f"URGENT: {super().summary()}"

print(UrgentMessage("Restart required").summary())

Sortie :

URGENT: Restart required

La méthode redéfinie appelle la méthode du parent, plutôt que de réécrire son comportement.

4. Préserver un comportement de base commun entre les objets

Les méthodes héritées peuvent être appelées sur différentes sous-classes ou instances parentes.

class Counter:
    def __init__(self, value):
        self.value = value

    def double(self):
        return self.value * 2

class LabeledCounter(Counter):
    def __init__(self, value, label):
        super().__init__(value)
        self.label = label

print(LabeledCounter(7, "items").double())

Sortie :

14

La sous-classe ajoute label sans perdre la méthode double() du parent.

• Définir un __init__ enfant en oubliant d'initialiser les attributs du parent.
• Passer self manuellement à super().__init__.
• Appeler une méthode parente sans ses arguments requis.
• Copier l'implémentation du parent au lieu de l'étendre avec super().