Was ist ein Trait?

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

Generics ermöglichen es dir, Code zu schreiben, der mit jedem Typ funktioniert, aber manchmal musst du garantieren, dass ein Typ etwas Bestimmtes kann. Hier kommen Traits ins Spiel.

Ein Trait definiert eine Reihe von Methoden, die ein Typ implementieren muss. Stell es dir als einen Vertrag vor: Jeder Typ, der diesen Vertrag „unterschreibt“, verspricht, das angegebene Verhalten bereitzustellen. Wenn du in anderen Sprachen Interfaces verwendet hast, erfüllen Traits einen ähnlichen Zweck.

So definierst du ein Trait:

trait Describable {
    fn describe(&self) -> String;
}

Das Schlüsselwort trait führt das Trait ein, gefolgt von seinem Namen. Innerhalb der geschweiften Klammern deklarierst du Methodensignaturen – lediglich den Namen, die Parameter und den Rückgabetyp, ohne Rumpf. Das Semikolon nach der Signatur zeigt an, dass es sich um eine Anforderung und nicht um eine Implementierung handelt.

Dieses Describable-Trait besagt: „Jeder Typ, der mich implementiert, muss eine describe-Methode bereitstellen, die eine Referenz auf sich selbst entgegennimmt und einen String zurückgibt.“ Das Trait kümmert sich nicht darum, wie die Methode funktioniert: Das bleibt jedem Typ überlassen, der es implementiert.

Traits werden mächtig, wenn mehrere unterschiedliche Typen dasselbe Trait implementieren. Ein Book, ein Car und eine Person könnten alle Describable sein, wobei jedes seine eigene einzigartige Beschreibung bereitstellt. Das Trait garantiert, dass sie alle diese gemeinsame Fähigkeit besitzen.

Aufgabe

Einfach

Definieren wir dein erstes Trait! Ein Trait legt einen Vertrag fest: ein Versprechen, dass jeder Typ, der es implementiert, ein bestimmtes Verhalten bereitstellt. Du erstellst ein Summarizable-Trait, das verschiedene Typen implementieren können, um eine Zusammenfassung ihrer selbst bereitzustellen.

Du wirst deinen Code auf zwei Dateien verteilen:

summary.rs: Definiere ein öffentliches Trait namens Summarizable mit einer einzigen Methodensignatur: summarize(&self) -> String. Denke daran: In einer Trait-Definition deklarierst du nur die Methodensignatur mit einem Semikolon: ohne Rumpf. Dadurch wird Rust mitgeteilt: „Jeder Typ, der dieses Trait implementiert, muss eine summarize-Methode bereitstellen, die einen String zurückgibt.“
main.rs: Binde dein Summary-Modul ein und gib eine Nachricht aus, die bestätigt, dass dein Trait definiert ist. Da wir noch nicht gelernt haben, wie man Traits implementiert (das ist die nächste Lektion!), überprüfst du einfach, dass dein Trait korrekt kompiliert.

Gib in deiner Hauptdatei die folgende Nachricht aus, um zu bestätigen, dass deine Trait-Definition gültig ist:

Summarizable trait defined successfully!

Diese Herausforderung konzentriert sich ausschließlich auf die Syntax der Trait-Definition: das Schlüsselwort trait, den Namen des Traits und das Deklarieren von Methodensignaturen ohne Implementierungen. In der nächsten Lektion lernst du, wie Structs dieses Trait implementieren können!

Probier es selbst

mod summary;

fn main() {
    // TODO: Gib die Bestätigungsnachricht aus, dass der Trait definiert ist
    // Expected output: "Summarizable trait defined successfully!"
    
}