Quand se produit la surcharge d'une méthode (overriding) en programmation?

La redéfinition de méthode se produit en héritage, lorsqu'une classe fille fournit sa propre implémentation d'une méthode déjà définie dans la classe parente. La signature de la méthode (nom, type de retour et nombre/type d'arguments) doit correspondre à celle de la méthode dans la classe parente. Cela permet au polymorphisme de fonctionner : un objet de la classe fille, utilisé comme un objet de la classe parente, appelle sa propre implémentation spécifique de la méthode.

Exemples d'utilisation :

• Modifier la logique du comportement hérité.
• Fournir une implémentation spécifique à la sous-classe pour une interface commune.

Points clés :

• Une relation est-un est requise (héritage).
• La signature de la méthode doit correspondre.
• Le modificateur d'accès peut être le même ou moins restrictif que celui de la méthode parente.
• Il n'est pas possible de redéfinir les méthodes final ou static (dans la plupart des langages).

// Exemple en Java
class Animal {
    public void makeSound() {
        System.out.println("Son animal générique");
    }
}

class Dog extends Animal {
    @Override // Annotation indiquant une redéfinition
    public void makeSound() {
        System.out.println("Wouf!");
    }
}

// Utilisation
// Animal myAnimal = new Animal();
// myAnimal.makeSound(); // Résultat : Son animal générique
//
// Animal myDog = new Dog();
// myDog.makeSound(); // Résultat : Wouf! (appel à la méthode redéfinie)

# Exemple en Python
class Animal:
    def make_sound(self):
        print("Son animal générique")

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

# Utilisation
# animal = Animal()
# animal.make_sound() # Résultat : Son animal générique
#
# dog = Dog()
# dog.make_sound() # Résultat : Wouf!