La surcharge désigne le concept selon lequel une classe enfant crée une nouvelle implémentation d’une méthode héritée. Lorsqu’une méthode dans une classe enfant est créée avec le même nom et la même signature qu’une méthode dans le parent, la méthode enfant l’emporte.

En réalité, nous avons utilisé le concept de surcharge une fois ou deux dans les deux chapitres précédents, par exemple avec le ContactSystem :

Chaque enfant implémente sa propre méthode send(message), qui se comporte différemment – elle envoie un SMS, un e-mail, ou un document à l’imprimante.

Et on peut faire cela simplement en écrivant une autre méthode dans la classe enfant ?

C’est aussi simple que ça ! Prenons cet exemple :

from abc import ABC   # permet de définir des classes de base
 
class Shape(ABC):
    def area(self):
        return 0
 
 
class Square(Shape):
    def __init__(self, length):
        self.length = length
 
    def area(self):
        return length * length

Dans cet exemple, Shape (“Forme”) contient une méthode de superficie qui renvoie une aire nulle pour la forme. Square (“Carré”) surcharge cette méthode en implémentant la formule pour l’aire d’un carré.

Bon, je comprends que area() est surchargé, mais qu’est-ce que c’est que cet ABC ?

ABC signifie « Abstract Base Class », ou « classe de base abstraite ». Il s’agit du mécanisme utilisé par Python pour implémenter ce que l’on nomme une classe abstraite.

Une classe abstraite est une classe qui ne peut pas être instanciée – la seule façon de l’utiliser est de créer une sous-classe. Par exemple, prenons le cas de Shape (“Forme”) – qu’est-ce que cela voudrait dire d’avoir un objet Shape? À quoi est-ce qu’il pourrait bien ressembler ? Nous pourrions faire de Square, ou Carré, une sous-classe de Shape, puis utiliser notre Carré. Cette approche nous permettrait d’avoir une classe parent commune pour Cercle, Carré, Triangle, etc., sans laisser personne instancier une Shape.

Bien que la surcharge nous permette de modifier entièrement des comportements hérités, il peut parfois être utile d’avoir accès au code des méthodes des classes parents, depuis les classes enfants.

L’un des emplacements les plus courants pour cette utilisation se trouve dans les constructeurs. Pour cela, nous utilisons super() – comme ceci :

class Drink:
    """Une boisson."""
 
    def __init__(self, price):
        """Initialise un prix."""
        self.price = price
 
    def drink(self):
        """Boire la boisson."""
        print("Je ne sais pas ce que c'est, mais je le bois.")
 
 
 
class Coffee(Drink):
    """Café."""
 
 
    prices = {"simple": 1, "serré": 1, "allongé": 1.5}
 
    def __init__(self, type):
        """Initialise le type du café."""
        self.type = type
        super().__init__(price=self.prices.get(type, 1))
 
 
    def drink(self):
    """Boire le café."""
        print("Un bon café pour me réveiller !")

Dans cet exemple, Coffee (“café”) est une sous-classe de Drink (“boisson”). La classe Coffee possède ses propres tarifs, qu’elle passe au constructeur de Drink pour initialiser le bon prix !

Est-ce qu’on ne pourrait pas plutôt simplement paramétrer self.price=self.prices.get(type, 1) dans le constructeur de Coffee ?

Oui, on pourrait, mais cette solution ne peut pas être mise à l’échelle. Imaginez que le constructeur de Drink applique d’autres opérations au prix (par exemple, appliquer une remise au comptoir), ou que CoffeE soit encore davantage sous-classé.

L’approche avec super() vous permet de réutiliser le code plutôt que de le copier, et assure le regroupement des fonctionnalités de façon logique – soit deux des plus grands avantages de la programmation orientée objet !

Finissons sur nos films : notre film en cassette ne rentre pas dans le lecteur DVD du salon… 🤔 Peut-être qu’avec la surcharge, nous pouvons proposer une vérification du lecteur (avant de casser le lecteur DVD !) :

Dans cet exercice, nous allons ajouter de la surcharge au code que nous avons utilisé au chapitre précédent.

Mais tout d’abord, voyez-vous des classes dans votre hiérarchie qui devraient être abstraites ? Si oui, transformez-les en classes abstraites.

Surchargez la méthode d’affichage de FilePost (ou de votre équivalent) pour afficher son fichier ( File ) correspondant en haut du post. Puis, surchargez la méthode d’affichage de votre classe Image pour écrire dans la sortie standard le nom de l’image.

Proposition

"""Définit les classes propres à notre forum. ;)"""
 
from abc import ABC
 
 
class File(ABC):
    """Fichier."""
 
    def __init__(self, name, size):
        """Initialise le nom et la taille."""
        self.name = name
        self.size = size
 
    def display(self):
        """Affiche le fichier."""
        pass
 
 
class ImageFile(File):
    """Fichier image."""
 
    def display(self):
        """Affiche l'image."""
        print(f"Fichier image '{self.name}'.")
 
 
class User:
    """Utilisateur."""
 
    def __init__(self, username, password):
        """Initialise le nom d'utilisateur et le mot de passe."""
        self.username = username
        self.password = password
 
    def login(self):
        """Connecte l'utilisateur."""
        print(f"L'utilisateur {self.username} est connecté.")
 
    def post(self, thread, content, file=None):
        """Poste un message dans un fil de discussion."""
        if file:
            post = FilePost(self, "aujourd'hui", content, file)
        else:
            post = Post(user=self, time_posted="aujourd'hui", content=content)
        thread.add_post(post)
        return post
 
    def make_thread(self, title, content):
        """Créé un nouveau fil de discussion."""
        post = Post(self, "aujourd'hui", content)
        return Thread(title, "aujourd'hui", post)
 
    def __str__(self):
        """représentation de l'utilisateur."""
        return self.username
 
 
class Moderator(User):
    """Utilisateur modérateur."""
 
    def edit(self, post, content):
        """Modifie un message."""
        post.content = content
 
    def delete(self, thread, post):
        """Supprime un message."""
        index = thread.posts.index(post)
        del thread.posts[index]
 
 
class Post:
    """Message."""
 
    def __init__(self, user, time_posted, content):
        """Initialise l'utilisateur, la date et le contenu."""
        self.user = user
        self.time_posted = time_posted
        self.content = content
 
    def display(self):
        """Affiche le message."""
        print(f"Message posté par {self.user} le {self.time_posted}:")
        print(self.content)
 
 
class FilePost(Post):
    """Message comportant un fichier."""
 
    def __init__(self, user, time_posted, content, file):
        """Initialise le fichier."""
        super().__init__(user, time_posted, content)
        self.file = file
 
    def display(self):
        """Affiche le contenu et le fichier."""
        super().display()
        print("pièce jointe:")
        self.file.display()
 
 
class Thread:
    """Fil de discussions."""
 
    def __init__(self, title, time_posted, post):
        """Initialise le titre, la date et les posts.
 
        Attention ici: on commence par un seul post, celui du sujet.
        Les réponses à ce post ne pourrons s'ajouter qu'ultérieurement.
        En effet, on ne créé pas directement un nouveau fil avec des réponses. ;)
        """
        self.title = title
        self.time_posted = time_posted
        self.posts = [post]
 
    def display(self):
        """Affiche le fil de discussion."""
        print("----- THREAD -----")
        print(f"titre: {self.title}, date: {self.time_posted}")
        print()
        for post in self.posts:
            post.display()
            print()
        print("------------------")
 
    def add_post(self, post):
        """Ajoute un post."""
        self.posts.append(post)

• Une classe enfant peut fournir sa propre implémentation d’un élément hérité de sa classe parent.
• L’implémentation de la classe enfant est prioritaire sur celle du parent – elle surcharge l’implémentation de la classe parent.
• On peut utiliser la méthode super() pour accéder à des méthodes dans la classe parent que nous avons surchargée.
• Une classe abstraite est une classe qui ne peut pas être instanciée – à la place, il faut en hériter.

Dans le chapitre suivant, nous nous pencherons sur différentes façons d’utiliser l’héritage : les hiérarchies d’héritage et l’héritage multiple.

• Classe abstraite en Python

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷