Redéfinir les comportements par défaut

Fait partie de la section Programmation Orientée Objet du Journey Rust de Coddy. Leçon 32 sur 61.

Les implémentations par défaut sont pratiques, mais parfois un type doit avoir un comportement différent de celui standard. Dans ce cas, vous pouvez remplacer l’implémentation par défaut en fournissant votre propre implémentation dans le bloc impl.

Définissez simplement la méthode avec la même signature, mais incluez votre logique personnalisée :

trait Greet {
    fn greet(&self) -> String {
        String::from("Hello there!")
    }
}

struct Robot {
    id: u32,
}

impl Greet for Robot {
    fn greet(&self) -> String {
        format!("BEEP BOOP. Unit {} online.", self.id)
    }
}

Bien que Greet fournisse une méthode greet default, Robot la remplace entièrement par sa propre version. Lorsque vous appelez greet() sur un Robot, Rust utilise l’implementation personnalisée :

let bot = Robot { id: 42 };
println!("{}", bot.greet());  // BEEP BOOP. Unité 42 en ligne.

Cela vous offre de la flexibilité : les types qui se satisfont du comportement par défaut n’ont rien à écrire, tandis que les types qui nécessitent un comportement spécialisé peuvent remplacer uniquement les méthodes qui les intéressent. Le trait garantit toujours que chaque type qui l’implémente dispose de la méthode.

Défi

Facile

Construisons un système de notification dans lequel différents types d’alertes peuvent personnaliser leurs messages ! Tu vas créer un trait avec une implémentation par défaut, puis faire en sorte qu’un type utilise la valeur par défaut tandis qu’un autre la remplace par un comportement personnalisé.

Tu organiseras ton code dans trois fichiers :

notifiable.rs : définis un trait public Notifiable avec une méthode notify(&self) -> String qui possède une implémentation par défaut renvoyant "Alert: Something happened!".
alerts.rs : crée deux structures publiques qui implémentent ton trait de manière différente :
- GenericAlert : une structure unitaire qui utilise la notification par défaut (bloc impl vide)
- UrgentAlert : une structure avec un champ public message (String) qui remplace la valeur par défaut pour renvoyer "URGENT: {message}", où {message} est son message enregistré
main.rs : regroupe tes modules et démontre les deux comportements. Crée un GenericAlert et un UrgentAlert à l’aide de l’entrée fournie, puis affiche leurs notifications.

L’idée essentielle est que GenericAlert obtient gratuitement un comportement grâce à la valeur par défaut, tandis que UrgentAlert fournit sa propre version spécialisée en définissant la méthode dans son bloc impl.

Ta sortie doit respecter ce format :

Alert: Something happened!
URGENT: {message}

Par exemple, avec l’entrée Server is down! :

Alert: Something happened!
URGENT: Server is down!

Tu recevras une entrée : le message de l’alerte urgente.

Essayez vous-même

mod notifiable;
mod alerts;

use alerts::{GenericAlert, UrgentAlert};
use notifiable::Notifiable;

fn main() {
    // Lire l'entrée pour le message de l'alerte urgente
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("Failed to read line");
    let message = input.trim().to_string();

    // TODO: Créer une instance de GenericAlert

    // TODO: Créer une instance d'UrgentAlert avec le message d'entrée

    // TODO: Afficher la notification de GenericAlert

    // TODO: Afficher la notification d'UrgentAlert
}