Redéfinition de méthode (@Override)

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 22 sur 87.

La redéfinition de méthode permet à une sous-classe de fournir sa propre implémentation d'une méthode qui est déjà définie dans sa classe parente. C'est ainsi que les classes enfants personnalisent le comportement hérité pour répondre à leurs besoins spécifiques.

Lorsque vous redéfinissez une méthode, la version de la sous-classe remplace complètement la version du parent pour les objets de cette sous-classe. La méthode doit avoir le même nom, le même type de retour et les mêmes paramètres que la méthode parente :

public class Animal {
    public void makeSound() {
        System.out.println("Some generic sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

L'annotation @Override indique au compilateur que vous avez l'intention de redéfinir une méthode parente. Bien qu'elle soit facultative, elle est fortement recommandée car le compilateur détectera les erreurs si vous orthographiez mal le nom de la méthode par accident ou si vous utilisez les mauvais paramètres :

@Override
public void makeSound() { }  // Correct - le compilateur vérifie ceci

public void makesound() { }  // Faute de frappe ! Crée une nouvelle méthode au lieu de la redéfinir

Lorsque vous appelez une méthode redéfinie, Java exécute la version qui appartient au type d'objet réel :

Dog dog = new Dog();
dog.makeSound();  // Résultat : Woof!

Cat cat = new Cat();
cat.makeSound();  // Résultat : Meow!

Rappelez-vous de la leçon précédente que vous pouvez utiliser super.methodName() à l'intérieur d'une méthode redéfinie si vous souhaitez toujours inclure le comportement du parent en plus de votre nouveau code.

Défi

Facile

Construisons un système de notification qui démontre comment les sous-classes peuvent surcharger les méthodes parentes pour fournir leur propre comportement spécialisé. Vous verrez comment l'annotation @Override aide à détecter les erreurs et comment chaque sous-classe peut personnaliser les méthodes héritées.

Vous allez créer trois fichiers pour organiser votre code :

Notification.java : Créez la classe parente qui représente une notification générique. Elle doit avoir :
- Un champ privé pour le message (String)
- Un constructeur qui accepte le message
- Une méthode getMessage() qui retourne le message
- Une méthode send() qui affiche : Sending notification: [message]
EmailNotification.java : Créez une sous-classe qui étend Notification et personnalise la manière dont les notifications sont envoyées par e-mail :
- Un champ privé pour l'adresse e-mail du recipient (String)
- Un constructeur qui prend à la fois le message et le destinataire, en utilisant super(message) pour la partie parente
- Surchargez la méthode send() en utilisant l'annotation @Override pour afficher : Emailing [recipient]: [message]
Main.java : Démontrez comment le même nom de méthode produit un comportement différent selon le type d'objet. Vous recevrez deux entrées : un message et une adresse e-mail. Créez à la fois une Notification régulière et une EmailNotification avec le même message, puis appelez send() sur chacune pour voir les différentes sorties.

Vous recevrez deux entrées : le message (String) et l'adresse e-mail du destinataire (String).

Votre sortie doit afficher deux lignes - la première provenant de la méthode send() du parent, puis de la version surchargée dans EmailNotification. Cela démontre comment la surcharge de méthode permet aux sous-classes de remplacer le comportement hérité par leur propre implémentation.

Aide-mémoire

La redéfinition de méthode (method overriding) permet à une sous-classe de fournir sa propre implémentation d'une méthode déjà définie dans sa classe parente. La méthode redéfinie doit avoir le même nom, le même type de retour et les mêmes paramètres que la méthode parente.

public class Animal {
    public void makeSound() {
        System.out.println("Some generic sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

L'annotation @Override est facultative mais fortement recommandée. Elle indique au compilateur que vous avez l'intention de redéfinir une méthode parente, ce qui aide à détecter des erreurs telles que des noms de méthodes mal orthographiés ou des paramètres incorrects :

@Override
public void makeSound() { }  // Correct - le compilateur vérifie ceci

public void makesound() { }  // Faute de frappe ! Crée une nouvelle méthode au lieu de la redéfinir

Lors de l'appel d'une méthode redéfinie, Java exécute la version qui appartient au type d'objet réel :

Dog dog = new Dog();
dog.makeSound();  // Output: Woof!

Cat cat = new Cat();
cat.makeSound();  // Output: Meow!

Vous pouvez utiliser super.methodName() à l'intérieur d'une méthode redéfinie pour inclure le comportement du parent en plus de votre nouveau code.

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les entrées
        String message = scanner.nextLine();
        String recipient = scanner.nextLine();
        
        // TODO: Créer un objet Notification avec le message
        
        // TODO: Créer un objet EmailNotification avec le message et le destinataire
        
        // TODO: Appeler send() sur l'objet Notification
        
        // TODO: Appeler send() sur l'objet EmailNotification
    }
}