Default et Static dans les Interfaces

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 37 sur 87.

À l’origine, les interfaces pouvaient uniquement contenir des méthodes abstraites sans implémentation. À partir de Java 8, les interfaces ont acquis la possibilité d’inclure des méthodes par défaut et des méthodes statiques, ce qui les rend plus flexibles.

Une méthode par défaut fournit une implémentation directement dans l’interface à l’aide du mot-clé default. Les classes qui implémentent l’interface héritent automatiquement de ce comportement, mais peuvent le redéfinir si nécessaire :

public interface Drawable {
    void draw();
    
    default void display() {
        System.out.println("Displaying on screen...");
        draw();
    }
}

Toute classe qui implémente Drawable obtient gratuitement la méthode display(). Cela est particulièrement utile pour ajouter de nouvelles méthodes aux interfaces existantes sans interrompre les classes qui les implémentent déjà.

Les méthodes statiques dans les interfaces fonctionnent comme les méthodes statiques dans les classes. Elles appartiennent à l’interface elle-même et sont appelées à l’aide du nom de l’interface :

public interface MathOperations {
    static int add(int a, int b) {
        return a + b;
    }
}

// Utilisation
int result = MathOperations.add(5, 3);

Les méthodes statiques d’une interface ne peuvent pas être redéfinies et ne sont pas héritées par les classes qui l’implémentent. Elles sont utiles pour les méthodes utilitaires liées à la fonction de l’interface.

Si une classe implémente deux interfaces possédant la même signature de méthode par défaut, la classe doit redéfinir cette méthode afin de résoudre le conflit.

Défi

Facile

Construisons un système de messagerie qui présente à la fois les méthodes par défaut et les méthodes statiques dans les interfaces. Tu vas créer une interface dotée de fonctionnalités intégrées que les classes qui l’implémentent peuvent utiliser directement ou personnaliser selon leurs besoins.

Tu organiseras ton code sur quatre fichiers :

Messenger.java : définis une interface qui représente tout service de messagerie. Elle doit déclarer une méthode abstraite sendMessage(String message) qui renvoie void. Ajoute une méthode par défaut appelée sendWithTimestamp(String message) qui affiche : [TIMESTAMP] , puis appelle sendMessage(message). Inclus également une méthode statique appelée formatMessage(String message) qui renvoie le message converti en majuscules.
EmailMessenger.java : crée une classe qui implémente Messenger. Elle possède un champ recipient (String). Inclus un constructeur pour initialiser le destinataire. Implémente sendMessage() afin d’afficher : Email to [recipient]: [message]. Cette classe utilise telle quelle la méthode par défaut sendWithTimestamp().
SMSMessenger.java : crée une autre classe qui implémente Messenger. Elle possède un champ phoneNumber (String). Inclus un constructeur pour initialiser le numéro de téléphone. Implémente sendMessage() afin d’afficher : SMS to [phoneNumber]: [message]. Redéfinis la méthode par défaut sendWithTimestamp() pour afficher : [URGENT] , puis appeler sendMessage(message) au lieu d’utiliser le comportement par défaut avec horodatage.
Main.java : rassemble tout afin de démontrer les méthodes d’interface par défaut et statiques. Tu recevras trois entrées : un destinataire e-mail, un numéro de téléphone et un message. Commence par utiliser la méthode statique Messenger.formatMessage() pour formater le message et le stocker. Crée ensuite un EmailMessenger et un SMSMessenger. Pour chaque service de messagerie, appelle sendWithTimestamp() avec le message formaté : remarque comment EmailMessenger utilise l’implémentation par défaut, tandis que SMSMessenger utilise sa version redéfinie.

Tu recevras trois entrées : le destinataire e-mail (String), le numéro de téléphone (String) et le message (String).

Ta sortie doit afficher quatre lignes au total : deux pour chaque service de messagerie : une ligne de préfixe ([TIMESTAMP] ou [URGENT]), suivie de la ligne du message. EmailMessenger affichera le préfixe d’horodatage par défaut, tandis que SMSMessenger affichera son préfixe urgent personnalisé. Tous deux utiliseront le message formaté statiquement (en majuscules) !

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 emailRecipient = scanner.nextLine();
        String phoneNumber = scanner.nextLine();
        String message = scanner.nextLine();
        
        // TODO: Utiliser Messenger.formatMessage() pour formater le message et le stocker
        
        // TODO: Créer un EmailMessenger avec le destinataire de l'e-mail
        
        // TODO: Créer un SMSMessenger avec le numéro de téléphone
        
        // TODO: Appeler sendWithTimestamp() sur l'EmailMessenger avec le message formaté
        
        // TODO: Appeler sendWithTimestamp() sur le SMSMessenger avec le message formaté
    }
}