8.3 Trait与多态

在面向对象编程（OOP）中，多态通常指“一个接口，多种实现”。Rust 没有传统的继承和虚函数，但它通过 Trait（特性） 实现了非常强大且类型安全的多态机制。Trait 是 Rust 中实现代码复用与行为抽象的核心工具，它允许我们定义一组方法签名，然后让不同的类型去实现这些方法，从而实现“鸭子类型”（Duck Typing）的编译时多态。

8.3.1 什么是 Trait？

Trait 可以理解为一种“能力”或“契约”。它定义了一组方法，任何实现了该 Trait 的类型都必须提供这些方法的具体实现。

定义 Trait：

// 定义一个名为 'Summary' 的 Trait
pub trait Summary {
    fn summarize(&self) -> String; // 方法签名，没有默认实现
}

为类型实现 Trait：

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

// 为 NewsArticle 实现 Summary Trait
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

// 为 Tweet 实现 Summary Trait
impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

现在，NewsArticle 和 Tweet 都实现了 Summary Trait，它们都拥有了 summarize() 方法，但行为完全不同。这就是多态的体现：同一个接口（summarize），不同的行为。

8.3.2 默认实现与覆盖

Trait 可以为方法提供默认实现。当类型实现该 Trait 时，可以选择使用默认实现，也可以覆盖它。

pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)") // 默认实现
    }
}

// 使用默认实现
pub struct EmptyArticle {
    pub title: String,
}

impl Summary for EmptyArticle {} // 无需提供方法体

fn main() {
    let article = EmptyArticle { title: String::from("Hello") };
    println!("{}", article.summarize()); // 输出: (Read more...)
}

8.3.3 Trait 作为参数：实现多态

Trait 最重要的用途之一是作为函数参数，允许函数接受任何实现了该 Trait 的类型。

方式一：impl Trait 语法（适用于简单场景）

fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

fn main() {
    let tweet = Tweet { ... };
    notify(&tweet); // 正确，Tweet 实现了 Summary
}

方式二：Trait Bound 语法（更通用，适用于复杂泛型约束）

fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

方式三：where 子句（当泛型参数多或约束复杂时，使签名更清晰）

fn notify<T>(item: &T)
where
    T: Summary,
{
    println!("Breaking news! {}", item.summarize());
}

8.3.4 返回实现了 Trait 的类型

函数可以返回实现了某个 Trait 的类型，但注意，返回的类型必须是单一的、具体的类型（不能返回 Trait 本身，因为 Trait 没有固定大小）。

fn returns_summarizable(switch: bool) -> impl Summary {
    if switch {
        NewsArticle { ... }
    } else {
        Tweet { ... } // 错误！只能返回一种具体类型
    }
}

注意：impl Trait 作为返回值，要求函数只能返回一种具体的类型。如果需要返回多种类型（如根据条件返回 NewsArticle 或 Tweet），则需要使用 Trait 对象（见下文）。

8.3.5 Trait 对象：动态分发

impl Trait 和泛型实现的静态分发（编译时确定具体类型），而 Trait 对象 实现了动态分发（运行时确定具体类型）。Trait 对象通过 dyn Trait 语法创建，通常放在 Box、Rc 或引用后面。

// 使用 Box<dyn Trait> 返回多种类型
fn returns_summarizable(switch: bool) -> Box<dyn Summary> {
    if switch {
        Box::new(NewsArticle { ... })
    } else {
        Box::new(Tweet { ... })
    }
}

fn main() {
    let obj: Box<dyn Summary> = returns_summarizable(true);
    println!("{}", obj.summarize()); // 运行时动态调用
}

Trait 对象与泛型的区别：

特性泛型（静态分发）Trait 对象（动态分发）
性能零成本抽象，编译时单态化，无运行时开销有运行时开销（虚函数表查找）
灵活性每个泛型实例化生成独立代码，代码膨胀一个指针指向虚表，代码体积小
类型编译时确定具体类型运行时确定具体类型
使用场景性能敏感，类型在编译时已知需要运行时多态，如集合中存放不同类型

8.3.6 多态与面向对象设计

Rust 的 Trait 多态鼓励 组合优于继承 的设计哲学。你可以通过组合多个 Trait 来构建复杂的行为，而不是通过深层次的类继承。

// 定义多个细粒度的 Trait
trait Drawable { fn draw(&self); }
trait Clickable { fn click(&self); }

// Button 实现了两个 Trait
struct Button;
impl Drawable for Button { fn draw(&self) { println!("Drawing Button"); } }
impl Clickable for Button { fn click(&self) { println!("Button clicked"); } }

// TextBox 只实现了 Drawable
struct TextBox;
impl Drawable for TextBox { fn draw(&self) { println!("Drawing TextBox"); } }

fn render(component: &dyn Drawable) {
    component.draw();
}

这种设计让代码更加灵活、可复用，并且避免了继承带来的菱形问题（Diamond Problem）和脆弱基类问题。

8.3.7 总结

Trait 是 Rust 实现多态的核心机制。通过 Trait，你可以：

  1. 定义共享行为：为不同的类型定义相同的方法签名。
  2. 实现静态多态：通过泛型约束（impl Trait、Trait Bound）在编译时绑定具体类型。
  3. 实现动态多态：通过 Trait 对象（dyn Trait）在运行时选择具体实现。
  4. 促进组合式设计：将功能拆分为独立的 Trait，按需组合，替代传统的继承体系。

掌握 Trait 与多态，是深入理解 Rust 类型系统、编写安全且灵活代码的关键一步。

Last Updated::