Trait 与泛型

这一课你将能做到

1. 定义 trait 并为类型实现，理解默认方法与跨类型扩展
2. 写泛型函数与 trait bound，区分静态分发（impl Trait/泛型）与动态分发（dyn Trait）
3. 给自定义类型实现 Display 等标准库 trait，接入生态工具链

为什么要学

Rust 没有 class 和继承，trait 就是它的「接口」——但比 Java interface 强得多：能带默认实现、能给已有类型补实现（包括 i32 这类基础类型）、能做编译期多态。泛型则对标 Java 泛型，但本质完全不同：Java 擦除成 Object 加运行时转型，Rust 单态化成具体类型的机器码，零装箱零虚调用。

判题系统里「不同语言的判题器」「不同风格的输出比对器」都是 trait 的标准应用。面试高频题「Rust 泛型和 Java 泛型区别」的答案全在这一课。

先建立图像

Java：  List<Checker> list = new ArrayList<>();   // 运行时多态，虚方法表
Rust：  泛型 fn run<C: Checker>(c: &C)            // 编译期为每个 C 生成专用代码（单态化）
        dyn Checker                                // trait 对象，类似 Java 的接口引用（虚表）

enum Outcome { Pass, Fail(String) }

trait Checker {
    fn check(&self, output: &str, expect: &str) -> Outcome;   // 必须实现
    fn name(&self) -> &str { "checker" }                      // 默认实现，可覆盖
}

跟着做

步骤 1：定义 trait 并实现

cargo new trait-demo
cd trait-demo

enum Outcome { Pass, Fail(String) }

trait Checker {
    fn check(&self, output: &str, expect: &str) -> Outcome;
    fn name(&self) -> &str { "checker" }
}

struct ExactChecker;

impl Checker for ExactChecker {
    fn check(&self, output: &str, expect: &str) -> Outcome {
        if output.trim() == expect.trim() {
            Outcome::Pass
        } else {
            Outcome::Fail(format!("期望 {expect}，实际 {output}"))
        }
    }
    fn name(&self) -> &str { "exact" }   // 覆盖默认实现
}

fn main() {
    let c = ExactChecker;
    match c.check("42\n", "42") {
        Outcome::Pass => println!("[{}] 通过", c.name()),
        Outcome::Fail(m) => println!("[{}] 失败：{m}", c.name()),
    }
}

impl Checker for ExactChecker：trait 与实现类型都必须在本 crate 或其中一方属于本 crate，否则编译器拒绝——孤儿规则保证全世界的 trait 实现不会冲突。

步骤 2：给已有类型补实现（Java 做不到的事）

trait Judge {
    fn judge_name(&self) -> String;
}

impl Judge for i32 {
    fn judge_name(&self) -> String {
        format!("判题器编号 {self}")
    }
}

fn main() {
    println!("{}", 7.judge_name());
}

可以为任意本地 trait 实现到任意类型上（含 i32），或为本地类型实现外来 trait（如 Display）——两头都是外来的才被孤儿规则拦截。

步骤 3：泛型与 trait bound

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut max = &list[0];
    for item in list {
        if item > max { max = item; }   // 没有 PartialOrd bound，> 就编译不过
    }
    max
}

fn main() {
    let times = vec![120u32, 990, 80, 1500];
    println!("最慢 {} ms", largest(&times));
    println!("最长 {:?}", largest(&["wa", "tle", "ac"]));
}

T: PartialOrd 是 trait bound：告诉编译器「T 必须支持 > 比较」。这是 Java 泛型 + interface 约束的合体，但检查全在编译期，运行时零开销。

步骤 4：impl Trait——签名更轻的 bound 写法

trait Checker {
    fn check(&self, output: &str, expect: &str) -> bool;
}

struct ExactChecker;
impl Checker for ExactChecker {
    fn check(&self, output: &str, expect: &str) -> bool {
        output.trim() == expect.trim()
    }
}

fn run(c: &impl Checker, output: &str, expect: &str) {   // 等价于泛型 + bound
    println!("比对结果：{}", c.check(output, expect));
}

fn default_checker() -> impl Checker {   // 返回「某个实现了 Checker 的具体类型」
    ExactChecker
}

fn main() {
    run(&ExactChecker, "42", "42");
    let c = default_checker();
    println!("{}", c.check("a ", "a"));
}

注意 -> impl Checker 不是「返回接口」：它仍然是静态分发，函数内所有分支必须返回同一个具体类型——这正是它和 Box<dyn Checker> 的核心区别。

步骤 5：dyn Trait——运行时多态（像 Java 一样）

// 沿用步骤 4 的 Checker 与 ExactChecker
struct IgnoreSpaceChecker;
impl Checker for IgnoreSpaceChecker {
    fn check(&self, output: &str, expect: &str) -> bool {
        let norm = |s: &str| s.lines().map(|l| l.trim_end()).collect::<Vec<_>>().join("\n");
        norm(output) == norm(expect)
    }
}

fn main() {
    // trait 对象：统一装进同一个集合，运行时经虚表分发
    let checkers: Vec<Box<dyn Checker>> =
        vec![Box::new(ExactChecker), Box::new(IgnoreSpaceChecker)];

    for (i, c) in checkers.iter().enumerate() {
        // "a \nb" 对比 "a\nb"：整体 trim 会失败，逐行去行尾空白则通过
        let ok = c.check("a \nb\n", "a\nb");
        println!("Checker #{}: {}", i + 1, if ok { "通过" } else { "失败" });
    }
}

type_name_of_val 需要 1.76+；若编译器版本不足，把最后一行删掉即可，不影响主线。选型口诀：编译期确定用泛型/impl Trait（更快），需要「同容器装多种类型」或「插件式扩展」用 dyn（更灵活）。

步骤 6：实现 Display 接入生态

use std::fmt;

enum Outcome { Pass, Fail(String) }

impl fmt::Display for Outcome {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Outcome::Pass => write!(f, "PASS"),
            Outcome::Fail(m) => write!(f, "FAIL({m})"),
        }
    }
}

fn main() {
    println!("{}", Outcome::Fail("diff line 3".into()));
    println!("{}", Outcome::Pass);
}

实现 Display 后自动获得 to_string() 方法，并让 {} 打印生效——生态里到处靠「实现某个 std trait」获得能力，这就是 Rust 的扩展机制。

讲清楚要点

1. trait = 行为契约：定义方法签名 + 默认实现；Java interface 只能约束类，trait 连 i32 都能约束。
2. 单态化 vs 擦除：Rust 泛型编译期展开成每种类型的专用机器码（无装箱、可内联）；Java 泛型运行时擦除为 Object。代价是 Rust 编译慢、二进制大。
3. 三种 bound 写法：fn f<T: Clone>(x: T)、fn f(x: impl Clone)、fn f<T>(x: T) where T: Clone——后者适合复杂约束与文档化。
4. 静态分发 vs 动态分发：泛型/impl Trait 编译期确定（零开销）；&dyn Trait / Box<dyn Trait> 运行时虚表（一次间接寻址，并要求 trait 对象安全）。
5. 孤儿规则：trait 或类型至少一方在本 crate，防止依赖图里的实现冲突，也是 Rust 生态无「菱形继承灾难」的原因。

你可能会懵的地方

• trait 和 Java interface 最关键的差异？ 三点：默认实现（Java 8 也有但受限）、能给任意类型补实现（包括基础类型）、既支持静态分发（泛型）又支持动态分发（dyn）。Java interface 只有动态分发一条路。

• impl Trait 参数和泛型参数有区别吗？ 参数位置完全等价（匿名泛型）；返回位置有本质区别——impl Trait 只能返回单一具体类型，泛型返回类型则由调用方决定。

• 什么时候必须用 dyn？ 同一集合装不同实现（Vec<Box<dyn Checker>>）、运行时由配置/插件决定实现、想减小泛型展开带来的编译膨胀。反之热路径优先泛型。

• 为什么我的 trait 不能做成 dyn？ 对象安全限制：trait 含泛型方法、或返回 Self，就无法构建统一虚表。解决：把泛型方法改成 &dyn 参数，或拆出对象安全子 trait。

• derive 和 impl 的关系？ derive 是编译器替你写 impl（如 #[derive(Debug)] 生成 Debug 实现），第 10 课展开；手写 impl 永远是兜底。

错法对照

错法	问题	正解
impl Checker 忘写目标类型	error[E0119] 冲突	语法固定为 impl Checker for Type
泛型函数里直接用 > / +	error[E0369] 未实现	补 bound：T: PartialOrd / T: Add<Output = T>
-> impl Trait 两个分支返回不同类型	error[E0308] 类型不同	统一返回同一类型，或改用 Box<dyn Trait>
对非对象安全 trait 用 dyn	error[E0038]	移除泛型方法/返回 Self，或拆子 trait
跨 crate 给外来类型实现外来 trait	孤儿规则 E0117	newtype 包装：struct MyVec(Vec<T>) 再实现

卡点急救

1. error[E0277] trait bound 不满足：报错会列出缺哪个 trait 的哪个方法。要么补 bound，要么给类型实现该 trait，要么换满足要求的类型。
2. error[E0038] not object safe：找到泛型方法或返回 Self 的方法；把 fn run<T: X>(&self, t: T) 改成 fn run(&self, t: &dyn X)，trait 就能做 dyn 了。
3. 同名方法歧义（两个 trait 都有 foo）：调用时显式限定 TraitA::foo(&obj)；实现侧不受影响。

面试常问

• Rust 泛型和 Java 泛型的本质区别？ Java 运行时擦除，泛型类型统一为 Object、需装箱与强制转换；Rust 编译期单态化，为每个具体类型生成专用机器码，零运行时开销、可内联优化，代价是编译时间与代码体积。

• 静态分发与动态分发如何选择？ 类型编译期可知、热路径追求性能：泛型/impl Trait（可内联、无间接跳转）；需要异构集合或运行时扩展：dyn Trait（虚表一次跳转，并要求对象安全）。判题内核这类微秒级路径用静态分发，插件注册处用 dyn。

• 孤儿规则解决什么问题？ 保证 trait 实现的全局唯一性，避免依赖树中两个 crate 给同一类型实现同一 trait 导致的冲突；与 newtype 模式配合，在规则内保留所有表达可能。

自测三问

1. fn f<T: Display>(x: T)、fn f(x: impl Display)、fn f(x: &dyn Display) 三者各自的分发方式是什么？
2. -> impl Checker 为什么不能在 if-else 两个分支返回两种类型？
3. 给 Vec<T> 这种外来类型实现外来 trait 会被什么规则拦截？标准解法是什么？

小结一句话

trait 把 Java 的接口升级成「可静态分发、可跨类型补实现、可默认实现」的行为契约——泛型单态化是 Rust 高频接口跑赢 JVM 的核心技术账。

延伸

• The Rust Book ch10：泛型、Trait 与生命周期
• 下一课：集合类型——Vec、String、HashMap 与迭代器链，判题数据的主战场。