Quand se produit la surcharge de méthode (Overriding) ?

La redéfinition de méthode en programmation orientée objet se produit lorsqu'une classe fille possède une méthode avec le même nom, la même signature (liste de paramètres) et le même type de retour qu'une méthode dans sa classe parente. Cela permet à la classe fille de fournir sa propre implémentation de la méthode héritée.

Conditions principales pour la redéfinition :

• Héritage : La classe fille doit hériter de la classe parente.
• Signature de la méthode : La méthode redéfinie dans la classe fille doit avoir la même signature (nom de la méthode et liste des types de paramètres, leur ordre et leur nombre) que la méthode dans la classe parente. Dans certains langages (par exemple, Java), il est également requis que le type de retour corresponde ou soit covariant.
• Modificateurs d'accès : Le modificateur d'accès de la méthode redéfinie dans la classe fille ne peut pas être plus restrictif que celui de la méthode dans la classe parente.
• À ne pas redéfinir : Les méthodes statiques (static), finales (final en Java, sealed en C#) et privées (private) ne participent pas au polymorphisme via l'héritage.

Exemple en Java :

// Classe parente
class Animal {
    public void sound() {
        // Implémentation par défaut
        System.out.println("Animal fait un son");
    }
}

// Classe fille redéfinissant la méthode sound()
class Dog extends Animal {
    @Override // Annotation pour vérification par le compilateur
    public void sound() {
        // Implémentation spécifique pour Dog
        System.out.println("Le chien aboie");
    }
}

class Main {
    public static void main(String[] args) {
        Animal monAnimal = new Animal();
        Animal monChienEnTantQueAnimal = new Dog(); // Polymorphisme
        Dog monChien = new Dog();

        monAnimal.sound();      // Appelle sound() de Animal
        monChienEnTantQueAnimal.sound(); // Appelle la version redéfinie de Dog (grâce au polymorphisme)
        monChien.sound();         // Appelle la version redéfinie de Dog
    }
}

Exemple en Python :

# Classe parente
class Animal:
    def sound(self):
        # Implémentation par défaut
        print("Animal fait un son")

# Classe fille redéfinissant la méthode sound()
class Dog(Animal):
    def sound(self):
        # Implémentation spécifique pour Dog
        print("Le chien aboie")

# Utilisation
mon_animal = Animal()
mon_chienEnTantQueAnimal = Dog() # Polymorphisme
mon_chien = Dog()

mon_animal.sound()       # Appelle sound() de Animal
mon_chienEnTantQueAnimal.sound()  # Appelle la version redéfinie de Dog (grâce au polymorphisme)
mon_chien.sound()          # Appelle la version redéfinie de Dog

La redéfinition est utilisée pour atteindre le polymorphisme à l'exécution, permettant d'effectuer différentes actions en fonction du type réel de l'objet, malgré l'utilisation d'une référence à la classe parente. C'est un principe clé de la programmation orientée objet pour construire des systèmes flexibles et extensibles.