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 déjà définie dans sa classe parente. C’est ainsi que les classes enfants personnalisent le comportement hérité pour l’adapter à leurs besoins spécifiques.

Lorsque vous redéfinissez une méthode, la version de la sous-classe remplace complètement celle de la classe parente 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 à celui de la méthode parente (ou un sous-type de celui-ci) :

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 faites accidentellement une faute d’orthographe dans le nom de la méthode ou utilisez 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 redéfinir

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

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

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

Souviens-toi de la leçon précédente : tu peux utiliser super.methodName() à l’intérieur d’une méthode redéfinie si tu veux toujours inclure le comportement du parent en plus de ton nouveau code.

Défi

Facile

Construisons un système de notifications qui montre comment les sous-classes peuvent redéfinir les méthodes de leur classe parente pour fournir leur propre comportement spécialisé. Tu verras comment l’annotation @Override aide à détecter les erreurs et comment chaque sous-classe peut personnaliser les méthodes héritées.

Tu vas créer trois fichiers pour organiser ton code :

Notification.java : crée la classe parente qui représente une notification générique. Elle doit contenir :
- un champ privé pour le message (String)
- un constructeur qui accepte le message
- une méthode getMessage() qui renvoie le message
- une méthode send() qui affiche : Sending notification: [message]
EmailNotification.java : crée 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 accepte à la fois le message et le destinataire, en utilisant super(message) pour la partie parente
- redéfinis la méthode send() à l’aide de l’annotation @Override pour afficher : Emailing [recipient]: [message]
Main.java : montre comment le même nom de méthode produit un comportement différent selon le type de l’objet. Tu recevras deux entrées : un message et une adresse e-mail. Crée à la fois une Notification ordinaire et une EmailNotification avec le même message, puis appelle send() sur chacune pour observer les différents résultats.

Tu recevras deux entrées : le message (String) et l’adresse e-mail du destinataire (String).

Ta sortie doit afficher deux lignes : la première provenant de la méthode send() de la classe parente, puis la seconde provenant de la version redéfinie dans EmailNotification. Cela montre comment la redéfinition 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: Create a Notification object with the message
        
        // TODO: Create an EmailNotification object with the message and recipient
        
        // TODO: Call send() on the Notification object
        
        // TODO: Call send() on the EmailNotification object
    }
}