Initialisation de la hiérarchie

7.1 Méthode super()

Vu qu'on parle d'héritage, ce serait judicieux de discuter des subtilités liées aux champs et méthodes de la classe de base. Pour ça, Python propose la méthode super(). Cette méthode est utilisée pour appeler des méthodes de la classe de base à l'intérieur d'une classe dérivée.

Elle a trois principaux cas d'utilisation :

Appel des méthodes de la classe parente :

La méthode super() permet d'appeler une méthode de la classe parente depuis la classe dérivée, sans indiquer explicitement le nom de la classe parente. C'est particulièrement utile en cas d'héritage multiple et aide à éviter les erreurs lors de modifications de la hiérarchie des classes.

Initialisation des classes de base :

super() est souvent utilisé dans le constructeur de la classe dérivée pour appeler le constructeur de la classe de base, ce qui permet d'initialiser les attributs de la classe de base dans la classe dérivée.

Support de l'héritage multiple :

Dans le cas d'un héritage multiple, super() résout correctement l'ordre d'appel des méthodes (MRO, Method Resolution Order), rendant son utilisation préférable à l'appel explicite des méthodes des classes parentes. On en reparlera un peu plus tard.

7.2 Constructeur de la classe de base

Le constructeur de la classe de base doit être appelé explicitement. Cela semble automatique, mais en réalité, ce n'est pas le cas. Les constructeurs des classes de base doivent toujours être appelés explicitement car il est souvent nécessaire de leur passer des arguments spécifiques.

Exemple :

class Animal:
    def __init__(self, type, name):
        self.type = type
        self.name = name
         
        
class Dog(Animal):
    def __init__(self, name):
        super().__init__("Chien", name)  # Appel du constructeur de la classe de base
        
class Cat(Animal):
    def __init__(self, name):
        super().__init__("Chat", name)  # Appel du constructeur de la classe de base
        
        
# Création d'un objet Dog
dog = Dog("Buddy")
print(dog) 

Dans cet exemple, le constructeur de la classe de base (Animal) a deux paramètres : le type de l'animal et son nom. Tandis que les classes héritières n'en ont qu'un — juste le nom.

C'est donc dans les constructeurs des classes Dog et Cat qu'il est décidé de ce qui doit être passé au constructeur de la classe de base — c'est-à-dire les types d'animaux « Chien » et « Chat ».

Donc :

• Il faut absolument appeler le constructeur de la classe de base dans le constructeur de la classe dérivée.
• Pour cela, il faut utiliser la méthode super().
• Pas besoin de passer l'argument self séparément — Python l'insère automatiquement lors de l'appel de la méthode.

7.3 Utilisation de la méthode super()

La méthode super() en Python peut être utilisée non seulement dans les constructeurs, mais aussi dans d'autres méthodes de classes pour appeler les méthodes de la classe parente. Cela peut être utile quand il est nécessaire d'étendre ou de modifier le comportement d'une méthode définie dans la classe parente.

Voyons quelques exemples :

Appel d'une méthode de la classe parente dans une méthode dérivée

Dans cet exemple, la méthode speak() de la classe Dog commence par appeler la méthode speak() de la classe Animal à l'aide de super(), puis ajoute son propre comportement.

class Animal:
    def speak(self):
        return "Un son animal générique"
        

class Dog(Animal):
    def speak(self):
        parent_speech = super().speak()  # Appel de la méthode de la classe parente
        return f"{parent_speech} Et le chien aboie !"
        
dog = Dog()
print(dog.speak())  # Affichera : Un son animal générique Et le chien aboie !

Appel d'une méthode de la classe parente pour vérifier l'état

Dans cet exemple, la méthode check_health() de la classe Dog appelle la méthode check_health() de la classe Animal pour ajouter des vérifications supplémentaires.

class Animal:
    def check_health(self):
        return "L'animal est en bonne santé"
        

class Dog(Animal):
    def check_health(self):
        parent_check = super().check_health()  # Appel de la méthode de la classe parente
        return f"{parent_check}. Le chien a besoin d'une promenade !"
        
dog = Dog()
print(dog.check_health())  # Affichera : L'animal est en bonne santé. Le chien a besoin d'une promenade !

Appel d'une méthode de la classe parente dans une méthode modifiant l'état

Dans cet exemple, la méthode withdraw() de la classe SavingsAccount vérifie d'abord si la limite de retrait est dépassée, et si ce n'est pas le cas, elle appelle la méthode withdraw() de la classe BankAccount pour effectuer l'opération.

class BankAccount:
    def __init__(self, balance):
        self.balance = balance
        

    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
            return f"Retrait de {amount}. Nouveau solde : {self.balance}"
        return "Fonds insuffisants"
        

class SavingsAccount(BankAccount):
    def withdraw(self, amount):
        if amount > 1000:
            return "Limite de retrait dépassée"
        return super().withdraw(amount)  # Appel de la méthode de la classe parente
        

savings = SavingsAccount(1500)
print(savings.withdraw(500))  # Affichera : Retrait de 500. Nouveau solde : 1000
print(savings.withdraw(1500))  # Affichera : Limite de retrait dépassée