⚡ 1. Was sind Traits?
Ein Trait (vergleichbar mit Interfaces in Java oder C#, aber deutlich mächtiger) definiert gemeinsame Funktionalität, die verschiedene Datentypen teilen können. Ein Trait beschreibt Methoden-Signaturen, die implementierende Typen bereitstellen müssen.
│ trait TelemetryReport │
├──────────────────────────────────┤
│ + summary(&self) -> String │
│ + severity_level(&self) -> u8 │ (Default: 1)
│ + is_critical(&self) -> bool │ (Default: sev >= 8)
└────────────────┬─────────────────┘
│ impl Trait for Type
┌────────────────┴────────────────┐
▼ ▼
┌───────────────────────┐ ┌───────────────────────┐
│ struct CpuMetric │ │ struct DiskAlert │
│ usage_percent: f64 │ │ device: String │
│ core_id: usize │ │ free_space_gb: u32 │
└───────────────────────┘ └───────────────────────┘
pub trait Summary {
// Erforderliche Methode
fn summarize(&self) -> String;
// Methode mit Default-Implementierung
fn is_highlighted(&self) -> bool {
false
}
}
pub struct NewsArticle {
pub headline: String,
pub author: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}: {}", self.headline, self.author)
}
}🛡️ 2. Trait Bounds & Mehrfach-Einschränkungen
Mit Trait Bounds legst du fest, dass ein generischer Typ bestimmte Eigenschaften aufweisen muss. Mehrere Bounds werden mit + kombiniert:
impl Trait
Kompakt für einfache Parameter: fn notify(item: &impl Summary)
Erzwingt gleiche Typen: fn notify<T: Summary + Display>(item: &T)
where Clauses
Erhöht Lesbarkeit bei vielen Typ-Parametern und komplexen Bounds.
// Mehrere Bounds mit 'where' Klausel
fn process_telemetry<T, U>(report: &T, target: &U) -> String
where
T: Summary + Clone,
U: std::fmt::Display,
{
format!("Sende Report [{}] an Target [{}]", report.summarize(), target)
}📑 3. Cheat-Sheet: Traits & Best Practices
| Konzept | Syntax / Rust-Code | Bedeutung |
|---|---|---|
| Trait Definition | pub trait Describable { fn desc(&self) -> String; } |
Definiert gemeinsame Methodensignaturen |
| Default Implementation | fn is_ok(&self) -> bool { true } |
Kann bei Bedarf im impl überschrieben werden |
| Mehrfach-Bounds | T: Summary + Clone + Send |
Typ muss alle angegebenen Traits erfüllen |
Return impl Trait |
fn create_reporter() -> impl Summary |
Kapselt den konkreten Typ vor dem Aufrufer |
🎯 Aufgaben & Checkliste in aufgabe.rs
In Rust kannst du einen Trait nur für einen Typen implementieren, wenn entweder der Trait oder der Typ in deiner eigenen Crate definiert ist. Das verhindert Namenskonflikte und sorgt für Stabilität im Ökosystem!