Methoden für Enums

Teil des Abschnitts Objektorientierte Programmierung der Rust-Journey von Coddy. Lektion 15 von 61.

Genau wie Structs können Enums Methoden haben, die in impl-Blöcken definiert sind. Dadurch kannst du Verhalten direkt an deinen Enum-Typ anhängen und problemlos mit verschiedenen Varianten über eine einheitliche Schnittstelle arbeiten.

So fügst du der Message-Aufzählung aus der vorherigen Lektion eine Methode hinzu:

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

impl Message {
    fn describe(&self) -> String {
        match self {
            Message::Quit => String::from("Quit signal"),
            Message::Move { x, y } => format!("Move to ({}, {})", x, y),
            Message::Write(text) => format!("Message: {}", text),
        }
    }
}

Der impl Message-Block funktioniert genau wie bei Strukturen. Die Methode nimmt &self, um auf die Enum-Instanz zuzugreifen. Innerhalb der Methode verwendest du match, um zu bestimmen, mit welcher Variante du es zu tun hast, und gibst das passende Ergebnis zurück.

Der Aufruf der Methode sieht unabhängig davon, welche Variante du hast, gleich aus:

fn main() {
    let m1 = Message::Quit;
    let m2 = Message::Move { x: 10, y: 20 };
    
    println!("{}", m1.describe());  // Quit-Signal
    println!("{}", m2.describe());  // Bewege nach (10, 20)
}

Dieses Muster ist leistungsfähig, weil der Aufrufer nicht wissen muss, welche Variante er hat. Er ruft einfach die Methode auf, und das Enum erledigt den Rest intern. Das Verhalten ändert sich je nach Variante, aber die Schnittstelle bleibt konsistent.

Aufgabe

Einfach

Erstellen wir ein Ampelsystem, das eine Aufzählung mit Methoden verwendet, um den aktuellen Signalzustand zu beschreiben. Jede Lichtfarbe enthält Informationen darüber, wie lange sie dauert, und eine Methode liefert eine für Menschen lesbare Beschreibung.

Du erstellst zwei Dateien, um deinen Code zu organisieren:

traffic.rs: Definiere eine öffentliche TrafficLight-Aufzählung mit drei Varianten:
- Red: enthält ein u32, das die Anzahl der zu wartenden Sekunden darstellt
- Yellow: enthält ein u32, das die Anzahl der zu wartenden Sekunden darstellt
- Green: enthält ein u32, das die Anzahl der Sekunden bis zum Weiterfahren darstellt
Implementiere anschließend eine status-Methode, die einen String zurückgibt, der die Ampel beschreibt. Verwende innerhalb der Methode match, um jede Variante zu behandeln, und füge die Dauer in die Nachricht ein.
main.rs: Binde dein Ampelmodul ein, erstelle Instanzen jeder Lichtvariante und rufe für jede die status-Methode auf, um die Beschreibungen auszugeben.

Die status-Methode soll Nachrichten in diesen exakten Formaten zurückgeben:

Für Red: Stop for {seconds} seconds
Für Yellow: Caution for {seconds} seconds
Für Green: Go for {seconds} seconds

Deine Ausgabe sollte den Status jeder Ampel in einer eigenen Zeile anzeigen:

Stop for {seconds} seconds
Caution for {seconds} seconds
Go for {seconds} seconds

Beispielsweise würde die Ausgabe bei einer roten Ampel mit 30 Sekunden, einer gelben mit 5 Sekunden und einer grünen mit 25 Sekunden folgendermaßen aussehen:

Stop for 30 seconds
Caution for 5 seconds
Go for 25 seconds

Du erhältst drei Eingaben: die Dauer der roten Ampel, die Dauer der gelben Ampel und die Dauer der grünen Ampel.

Probier es selbst

mod traffic;

use traffic::TrafficLight;

fn main() {
    // Eingabe für Dauern lesen
    let mut red_input = String::new();
    std::io::stdin().read_line(&mut red_input).expect("Failed to read line");
    let red_duration: u32 = red_input.trim().parse().expect("Invalid number");

    let mut yellow_input = String::new();
    std::io::stdin().read_line(&mut yellow_input).expect("Failed to read line");
    let yellow_duration: u32 = yellow_input.trim().parse().expect("Invalid number");

    let mut green_input = String::new();
    std::io::stdin().read_line(&mut green_input).expect("Failed to read line");
    let green_duration: u32 = green_input.trim().parse().expect("Invalid number");

    // TODO: Erstelle Instanzen jeder TrafficLight-Variante mit den Eingabe-Dauern

    // TODO: Rufe die status-Methode auf jedem Licht auf und gib das Ergebnis aus
}