【Rust 基础入门】(12) | 特征 (Traits)

在之前的章节中，我们通过结构体、枚举和方法为类型赋予了具体的行为。现在，我们要迈向一个更抽象的层次：特征（Traits）。在 Rust 中，特征是定义类型共享行为的基石，不仅是一种语法工具，更是 Rust 类型系统和代码复用哲学的核心体现。

想象一下，吉他和钢琴是两种截然不同的乐器：吉他靠拨弦发出声音，钢琴通过敲击琴键演奏旋律。但作为乐器，它们都具备“演奏”的能力。特征就像这份共同的“演奏契约”，它规定了行为的外观（方法签名），而具体如何演奏——是拨弦的节奏还是按键的旋律——则由每种乐器自己决定。这正是 Rust 特征的本质：通过一组方法签名建立行为的规范，让不同类型以自己的方式实现。

定义和实现特征

假设我们想让乐器都能“演奏”，可以用 trait 关键字定义一个 Instrument 特征：

trait Instrument {
    // 方法签名，描述“演奏”行为，返回演奏描述
    fn play(&self) -> String;
}

接下来，为 Guitar 和 Piano 两个结构体实现这个特征：

struct Guitar {
    strings: u32,  // 吉他有几根弦
}

impl Instrument for Guitar {
    fn play(&self) -> String {
        format!("Strumming {} strings with a rhythm!", self.strings)
    }
}

struct Piano {
    keys: u32,  // 钢琴有几个键
}

impl Instrument for Piano {
    fn play(&self) -> String {
        format!("Pressing {} keys in a melody!", self.keys)
    }
}

在这段代码中，Instrument 特征定义了 play 方法，要求实现者返回一个字符串。Guitar 和 Piano 通过 impl Instrument for ... 提供了各自的实现。你会注意到 &self 参数，这是 Rust 方法的标准写法，表示行为作用于实例本身。运行以下代码看看效果：

fn main() {
    let my_guitar = Guitar { strings: 6 };
    let my_piano = Piano { keys: 88 };

    println!("{}", my_guitar.play());  // 输出: Strumming 6 strings with a rhythm!
    println!("{}", my_piano.play());  // 输出: Pressing 88 keys in a melody!
}

这里，特征就像一个指挥家，确保每种乐器都能“演奏”，但演奏的方式完全由乐器自己决定。这种一致性与多样性的结合，正是特征的价值所在。

默认实现

Rust的特征不仅能定义接口，还允许为方法提供默认实现。这就像给乐器预设一个通用的调音方式：大多数乐器可以直接用这个标准流程，但如果需要特别调整，也可以自定义。

让我们为 Instrument 添加一个 tune 方法，带上默认实现：

trait Instrument {
    fn play(&self) -> String;

    // 默认实现，可选择覆盖
    fn tune(&self) -> String {
        String::from("Tuning to standard pitch...")
    }
}

struct Guitar {
    strings: u32,
}

impl Instrument for Guitar {
    fn play(&self) -> String {
        format!("Strumming {} strings with a rhythm!", self.strings)
    }
    // 不实现tune，使用默认版本
}

struct Piano {
    keys: u32,
}

impl Instrument for Piano {
    fn play(&self) -> String {
        format!("Pressing {} keys in a melody!", self.keys)
    }

    // 覆盖tune，提供自定义实现
    fn tune(&self) -> String {
        format!("Adjusting {} keys with a tuning hammer!", self.keys)
    }
}

试试看：

fn main() {
    let guitar = Guitar { strings: 6 };
    let piano = Piano { keys: 88 };

    println!("{}", guitar.tune());  // 输出: Tuning to standard pitch...
    println!("{}", piano.tune());  // 输出: Adjusting 88 keys with a tuning hammer!
}

Guitar直接用了默认的调音方式，而 Piano 选择了更具体的实现。默认实现减少了重复代码，同时保留了灵活性——这在 Rust 标准库中是常见的设计，比如 Default 特征。

关联类型

特征还有一个强大的功能：关联类型（Associated Types） 。如果说特征是一份演奏契约，那么关联类型就像乐谱中的音符标记，它规定了一个占位符类型，但具体是什么音符（类型），由实现者来决定。这种方式让特征在定义行为时不必提前锁定具体类型，增加了灵活性。

让我们扩展 Instrument 特征，添加一个方法 sound，表示乐器发出的声音类型，具体类型通过关联类型指定：

trait Instrument {
    fn play(&self) -> String;

    fn tune(&self) -> String {
        String::from("Tuning to standard pitch...")
    }

    type Sound;  // 关联类型，表示声音的类型

    fn sound(&self) -> Self::Sound;
}

现在，为 Guitar 和 Piano 实现这个特征：

struct Guitar {
    strings: u32,
}

impl Instrument for Guitar {
    fn play(&self) -> String {
        format!("Strumming {} strings with a rhythm!", self.strings)
    }

    type Sound = String;  // 吉他的声音用字符串描述

    fn sound(&self) -> Self::Sound {
        "Twang!".to_string()
    }
}

struct Piano {
    keys: u32,
}

impl Instrument for Piano {
    fn play(&self) -> String {
        format!("Pressing {} keys in a melody!", self.keys)
    }

    fn tune(&self) -> String {
        format!("Adjusting {} keys with a tuning hammer!", self.keys)
    }

    type Sound = u32;  // 钢琴的声音用响度（分贝）表示

    fn sound(&self) -> Self::Sound {
        85  // 假设钢琴声为85分贝
    }
}

试运行：

fn main() {
    let guitar = Guitar { strings: 6 };
    let piano = Piano { keys: 88 };

    println!("Guitar sound: {}", guitar.sound());  // 输出: Guitar sound: Twang!
    println!("Piano sound: {} dB", piano.sound()); // 输出: Piano sound: 85 dB
}

在这里，Instrument 特征通过关联类型 Sound 定义了一个抽象的返回类型。Guitar 选择用 String 表示拨弦的“Twang!”声，Piano 用 u32 表示声音的响度。就像乐谱上的音符可以是高音或低音，关联类型让特征的实现更加多样化。

小结

• 特征（Traits）是 Rust 中定义行为契约的机制，通过方法签名规范类型的功能。
• 类型通过 impl Trait for Type 实现特征，可以自定义实现，也可借助默认行为。
• 关联类型为特征增加了灵活性，允许实现者指定相关类型。
• 特征是 Rust 抽象编程的起点，连接了具体实现与通用设计。

掌握特征后，你已经触及了Rust编程的灵魂。下一章，我们将结合泛型，探索如何用特征打造更灵活、高效的代码。