10.2 特性（Traits）的定义与实现
特性（Traits）是 Rust 中的重要语言特性，它用于定义一组可以共享的行为。可以将特性视为一种接口，通过特性可以声明某些类型需要实现的函数和行为，从而实现多态性和代码复用。
10.2.1 什么是特性
特性是一组方法的集合，用于定义某些类型的公共接口。特性本身不能直接存储数据，它仅定义方法签名，而具体实现则由实现特性的类型提供。
特性的定义语法
特性使用 trait 关键字定义，语法如下：
1
2
3
|
trait TraitName {
fn method_name(&self);
}
|
10.2.2 定义与实现特性
定义一个特性
以下是一个简单的特性定义示例：
1
2
3
|
trait Describable {
fn describe(&self) -> String;
}
|
为类型实现特性
使用 impl TraitName for Type 为特定类型实现特性。例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
struct Person {
name: String,
age: u32,
}
impl Describable for Person {
fn describe(&self) -> String {
format!("{} is {} years old.", self.name, self.age)
}
}
fn main() {
let alice = Person {
name: String::from("Alice"),
age: 30,
};
println!("{}", alice.describe());
}
|
在这个例子中，Person 类型实现了 Describable 特性，从而可以调用 describe 方法。
10.2.3 默认方法
特性中可以定义默认方法，类型可以选择使用默认实现，或者提供自己的实现。
定义默认方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
trait Greeter {
fn greet(&self) {
println!("Hello!");
}
}
struct Robot;
impl Greeter for Robot {}
fn main() {
let robot = Robot;
robot.greet(); // 输出: Hello!
}
|
如果类型没有提供自己的实现，则会使用特性中的默认实现。
覆盖默认方法
1
2
3
4
5
|
impl Greeter for Person {
fn greet(&self) {
println!("Hi, I am {}!", self.name);
}
}
|
10.2.4 特性的多态性
通过特性，可以实现多态性，使得代码能够处理实现了相同特性的不同类型。
动态分派
动态分派使用特性对象（trait objects），通过 &dyn TraitName 或 Box<dyn TraitName> 来表示实现了特性的动态类型。
1
2
3
4
5
6
7
8
9
10
11
12
|
fn describe_object(obj: &dyn Describable) {
println!("{}", obj.describe());
}
fn main() {
let alice = Person {
name: String::from("Alice"),
age: 30,
};
describe_object(&alice); // 输出: Alice is 30 years old.
}
|
静态分派
静态分派通过泛型实现，在编译时确定类型，性能更高。
1
2
3
4
5
6
7
8
9
10
11
12
|
fn describe_static<T: Describable>(item: T) {
println!("{}", item.describe());
}
fn main() {
let alice = Person {
name: String::from("Alice"),
age: 30,
};
describe_static(alice);
}
|
10.2.5 特性约束
特性可以用作泛型参数的约束，确保泛型类型必须实现某些特性。
简单约束
1
2
3
|
fn print_description<T: Describable>(item: T) {
println!("{}", item.describe());
}
|
多重约束
可以同时约束多个特性：
1
2
3
4
5
6
7
8
|
trait Printable {
fn print(&self);
}
fn display<T: Describable + Printable>(item: T) {
item.print();
println!("{}", item.describe());
}
|
where 子句
where 子句使复杂的特性约束更加清晰：
1
2
3
4
5
6
7
|
fn display<T>(item: T)
where
T: Describable + Printable,
{
item.print();
println!("{}", item.describe());
}
|
10.2.6 特性与标准库
Rust 标准库中定义了许多常用特性，例如：
std::fmt::Display：用于格式化打印。std::ops::Add：用于定义 + 运算符的行为。std::iter::Iterator：迭代器相关特性。
实现标准特性
开发者可以为自己的类型实现标准特性，例如 Display：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
use std::fmt;
struct Point {
x: i32,
y: i32,
}
impl fmt::Display for Point {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({}, {})", self.x, self.y)
}
}
fn main() {
let point = Point { x: 10, y: 20 };
println!("{}", point); // 输出: (10, 20)
}
|
10.2.7 特性的限制与注意事项
- 孤儿规则：只有当特性或类型至少有一个定义在当前 crate 中时，才能为该类型实现特性。
- 避免特性冲突：如果两个特性提供了同名方法，可能会引发冲突，应明确调用路径。
- 性能考虑：动态分派的性能略低于静态分派，应根据需求选择合适的实现方式。
10.2.8 小结
- 特性定义了类型必须实现的一组方法，为代码的行为抽象提供了强大的工具。
- 可以为类型提供默认方法，也可以为特定类型自定义实现。
- 特性结合泛型能够实现静态分派，而特性对象支持动态分派。
- Rust 的强类型系统和特性约束确保了代码的安全性和可维护性。
下一节将介绍特性约束与特化，深入探讨如何在更复杂的场景中使用特性。