Summary  
This chapter covers method overriding, where subclasses provide their own implementations of methods defined in a parent class to enable polymorphism and consistent interfaces, with the option to extend parent behavior using super().  

General domain of usage  
Graphics rendering

La **surcharge de méthode** est un mécanisme clé qui permet le **polymorphisme** dans la programmation orientée objet basée sur l'héritage. Elle permet aux classes enfants de fournir des implémentations spécialisées des méthodes définies dans leurs classes parentes, constituant ainsi la base du comportement polymorphe.

Définition

class Vehicle:
    def move(self):
        return "The vehicle is moving"

class Car(Vehicle):
    def move(self):
        return "The car is driving"

class Boat(Vehicle):
    def move(self):
        return "The boat is sailing"

vehicles = [Car(), Boat()]

for v in vehicles:
    print(v.move())

La **surcharge de méthode** permet à des objets de types différents de répondre chacun à leur manière aux mêmes appels de méthode tout en conservant une interface cohérente. Une façon claire de le démontrer est d'utiliser des exemples avec des animaux, des véhicules et des scénarios réels. Grâce à la surcharge, le code devient plus flexible, réutilisable et adaptable.

Les concepts fondamentaux de la surcharge de méthode abordés incluent la mécanique de la surcharge, le comportement polymorphe et l'utilisation de `Super()` :


- Les méthodes de la classe enfant remplacent les méthodes de la classe parente portant le même nom ;

- Maintien de la signature de la méthode tout en modifiant l’implémentation ;

- La hiérarchie d’héritage détermine la résolution des méthodes ;

- Permet un comportement spécialisé dans les sous-classes.

Mécanismes de redéfinition

- Le même appel de méthode déclenche différentes implémentations ;

- Les références de la classe parente peuvent contenir des objets de la classe enfant ;

- Distribution des méthodes à l’exécution selon le type réel de l’objet ;

- Permet d’écrire du code générique fonctionnant avec des objets spécialisés.

Comportement polymorphe

- Accès aux méthodes de la classe parente depuis les méthodes redéfinies ;
- Extension plutôt que remplacement complet des fonctionnalités parentes ;
- Maintien de la réutilisation du code tout en ajoutant des spécialisations ;
- Construction incrémentielle sur les implémentations existantes.

Utilisation de super()

Quelle affirmation décrit le mieux le rôle de la redéfinition de méthode ?

Apprenez à créer des applications propres, sécurisées et évolutives avec la programmation orientée objet en Python. Couvrez les fondamentaux des classes et des objets, puis passez à des concepts avancés tels que l'héritage, la composition, le polymorphisme et l'encapsulation. Grâce à des explications claires et des exemples pratiques, vous développerez la capacité de concevoir des programmes Python puissants, maintenables et prêts pour une utilisation réelle.

Découvrez les éléments fondamentaux de la programmation orientée objet en Python. Cette section aborde les classes, les objets, les méthodes et les variables, vous offrant une base solide pour comprendre comment la POO organise et structure le code.

Découvrez comment les classes peuvent partager et étendre des fonctionnalités. Vous étudierez différents modèles d'héritage, des hiérarchies simples à l'héritage multiple et aux classes abstraites, et verrez comment ils permettent la réutilisation du code et l'évolutivité.

Découvrez comment créer des systèmes flexibles en combinant des objets. Plutôt que de s'appuyer uniquement sur l'héritage, vous verrez comment la composition permet d'assembler des comportements de manière modulaire et adaptable.

Comprendre comment différents objets peuvent partager une interface commune tout en ayant des comportements propres. Cette section montre comment la redéfinition de méthodes, les interfaces et les protocoles rendent le code plus dynamique et réutilisable.

Découvrez comment protéger les données internes et contrôler l'accès aux attributs de classe. Vous étudierez les attributs privés, les accesseurs et mutateurs, ainsi que les techniques de masquage des données qui assurent la sécurité et la maintenabilité de vos classes.

Redéfinition des méthodes