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 et les mêmes paramètres que la méthode parente, ainsi qu'un type de retour identique à (ou un sous-type de) celui du parent :

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 ou si vous utilisez les mauvais paramètres :

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

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 devrait afficher deux lignes - d'abord à partir de la méthode send() du parent, puis à partir 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.

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
    }
}