Qu'est-ce que la surcharge (Overriding) en…

La redéfinition de méthode (Overriding) est la capacité d'une sous-classe à fournir sa propre implémentation d'une méthode déjà définie dans sa classe parente. La signature de la méthode redéfinie (nom, nombre et types de paramètres) dans la sous-classe doit correspondre exactement à celle de la méthode dans la classe parente. Le type de valeur de retour doit également être le même ou être covariant (sous-type) du type de retour de la méthode dans la classe parente.

Principaux aspects de la redéfinition :

Héritage : La redéfinition n'est possible que dans le contexte des relations d'héritage, où la sous-classe hérite d'une méthode de la super-classe.
Polymorphisme : La redéfinition est l'un des mécanismes de mise en œuvre du polymorphisme à l'exécution (runtime polymorphism). Cela signifie qu'en fonction du type réel de l'objet, appelé via une référence au type parent, la mise en œuvre appropriée de la méthode sera exécutée (soit celle du parent, soit celle de l'enfant).
Mot-clé @Override : Dans certains langages (par exemple, Java), l'annotation @Override est utilisée. Elle n'est pas obligatoire pour que la redéfinition fonctionne correctement, mais elle est recommandée pour améliorer la lisibilité du code et prévenir les erreurs de compilation si la méthode ne respecte pas les règles de redéfinition.
Accès à la méthode du parent : À l'intérieur de la méthode redéfinie dans la sous-classe, il est souvent nécessaire d'appeler l'implémentation de la même méthode dans la classe parente. Pour cela, on utilise le mot-clé super (par exemple, super.méthode()).

Exemple en Java :

// Classe parente
class Animal {
    // Méthode dans la classe parente
    void makeSound() {
        System.out.println("L'animal fait un son");
    }
}

// Classe enfant héritant de Animal
class Dog extends Animal {
    // Redéfinition de la méthode makeSound()
    @Override
    void makeSound() {
        System.out.println("Wouf wouf!");
    }

    // Exemple d'appel à la méthode du parent
    void eat() {
        System.out.println("Le chien mange.");
        super.makeSound(); // Appel à la méthode de la classe parente
    }
}

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

        myAnimal.makeSound(); // Affiche : L'animal fait un son
        myDog.makeSound();   // Affiche : Wouf wouf! (Appel de la méthode redéfinie)

        Dog specificDog = new Dog();
        specificDog.eat(); // Affiche : Le chien mange. 
                          // L'animal fait un son
    }
}

Exemple en Python :

# Classe parente
class Animal:
    # Méthode dans la classe parente
    def make_sound(self):
        print("L'animal fait un son")

# Classe enfant héritant de Animal
class Dog(Animal):
    # Redéfinition de la méthode make_sound()
    def make_sound(self):
        print("Wouf wouf!")

    # Exemple d'appel à la méthode du parent
    def eat(self):
        print("Le chien mange.")
        super().make_sound() # Appel à la méthode de la classe parente

# Démonstration
my_animal = Animal()
my_dog = Dog() # Polymorphisme

my_animal.make_sound() # Affiche : L'animal fait un son
my_dog.make_sound()   # Affiche : Wouf wouf!

specific_dog = Dog()
specific_dog.eat() # Affiche : Le chien mange. 
                      # L'animal fait un son

La redéfinition est utilisée pour adapter le comportement de la classe de base aux spécificités de la sous-classe, tout en conservant l'interface générale. C'est un élément clé de la conception orientée objet.

Qu'est-ce que la surcharge (Overriding) en programmation?