Rust语言从入门到精通系列 - Trait 特征

在 Rust 中，Trait 是一种定义方法集合的机制。Trait 可以被用来定义一个或多个类型所共享的行为。Trait 与接口相似，但是 Trait 可以拥有默认实现，这使得 Trait 在 Rust 中的使用更加灵活。

在本教程中，我们将使用一个 Animal 结构体来演示 Trait 的使用。Animal 结构体将被用于实现一些基本的动物行为，例如移动、发出声音等。

类似于Java语言中的interface, 但是用法又有些区别.

Animal 结构体

首先，我们需要定义 Animal 结构体。Animal 结构体将包含一些基本的属性和方法，例如 name、age、move_to 和 make_sound。

#[derive(Debug)]
struct Animal {
    name: String,
    age: u8,
}

impl Animal {
    fn move_to(&self, x: u8, y: u8) {
        println!("{} is moving to ({}, {})", self.name, x, y);
    }

    fn make_sound(&self) {
        println!("{} is making a sound", self.name);
    }
}

在上面的代码中，我们定义了一个 Animal 结构体，该结构体包含了两个属性：name 和 age。我们还定义了两个方法：move_to 和 make_sound。move_to 方法接受两个参数，x 和 y，用于指定 Animal 的目标位置。make_sound 方法不接受任何参数，用于让 Animal 发出声音。

现在，我们可以创建一个 Animal 的实例，并调用 move_to 和 make_sound 方法：

fn main() {
    let animal = Animal { name: String::from("Tiger"), age: 3 };
    animal.move_to(10, 20);
    animal.make_sound();
}

上面的代码将创建一个名为 Tiger 的 Animal 实例，年龄为 3 岁。我们随后调用了该实例的 move_to 和 make_sound 方法。

使用 Trait 实现 Animal 行为

现在，我们将使用 Trait 来实现 Animal 的行为。我们将定义一个叫做 AnimalBehavior 的 Trait，该 Trait 包含了 Animal 所需的所有方法。然后，我们将让 Animal 结构体实现 AnimalBehavior Trait。

trait AnimalBehavior {
    fn move_to(&self, x: u8, y: u8);
    fn make_sound(&self);
}

在上面的代码中，我们定义了一个 AnimalBehavior Trait，该 Trait 包含了两个方法：move_to 和 make_sound。这两个方法与我们之前定义的 Animal 结构体中的方法完全相同。

现在，我们将让 Animal 结构体实现 AnimalBehavior Trait：

impl AnimalBehavior for Animal {
    fn move_to(&self, x: u8, y: u8) {
        println!("{} is moving to ({}, {})", self.name, x, y);
    }

    fn make_sound(&self) {
        println!("{} is making a sound", self.name);
    }
}

在上面的代码中，我们使用 impl 关键字来实现 AnimalBehavior Trait。我们将 AnimalBehavior Trait 的方法与 Animal 结构体中的方法进行了匹配。现在，Animal 结构体可以被视为实现了 AnimalBehavior Trait。

现在，我们可以创建一个 Animal 实例，并将其视为 AnimalBehavior Trait 的实现。然后，我们可以调用 AnimalBehavior Trait 中定义的方法：

fn main() {
    let animal = Animal {
        name: String::from("Tiger"),
        age: 3,
    };
    let animal_behavior: &dyn AnimalBehavior = &animal;
    animal_behavior.move_to(10, 20);
    animal_behavior.make_sound();
}
//  输出结果:
// Tiger is moving to (10, 20)
// Tiger is making a sound

在上面的代码中，我们创建了一个 Animal 实例，并将其视为 AnimalBehavior Trait 的实现。我们还定义了一个名为 animal_behavior 的变量，该变量是一个指向 AnimalBehavior Trait 的引用。最后，我们调用了 animal_behavior 的 move_to 和 make_sound 方法。

Trait 的默认实现 Trait 可以包含默认实现。这意味着 Trait 的方法可以被实现，但是如果实现没有提供自己的实现，Trait 的默认实现将被使用。

在下面的代码中，我们将为 AnimalBehavior Trait 添加一个默认实现：

trait AnimalBehavior { 
    fn move_to(&self, x: u8, y: u8) { 
        println!("{} is moving to ({}, {})", self.name, x, y); 
    }

    fn make_sound(&self) {
        println!("{} is making a sound", self.name);
    }

    fn eat(&self) {
        println!("{} is eating", self.name);
    }
}

在上面的代码中，我们为 AnimalBehavior Trait 添加了一个新的方法 eat，并为 move_to 和 make_sound 方法提供了默认实现。现在，Animal 结构体可以选择实现 eat 方法，但是如果没有提供自己的实现，Trait 的默认实现将被使用。

现在，我们可以创建一个 Animal 实例，并将其视为 AnimalBehavior Trait 的实现。然后，我们可以调用 AnimalBehavior Trait 中定义的方法，包括 eat 方法：

fn main() {
    let animal = Animal {
        name: String::from("Tiger"),
        age: 3,
    };
    let animal_behavior: &dyn AnimalBehavior = &animal;
    animal_behavior.move_to(10, 20);
    animal_behavior.make_sound();
    animal_behavior.eat();
}

在上面的代码中，我们创建了一个 Animal 实例，并将其视为 AnimalBehavior Trait 的实现。我们还定义了一个名为 animal_behavior 的变量，该变量是一个指向 AnimalBehavior Trait 的引用。最后，我们调用了 animal_behavior 的 move_to、make_sound 和 eat 方法。由于 Animal 结构体没有提供自己的 eat 方法实现，Trait 的默认实现将被使用。

Trait 的泛型

Trait 可以与泛型一起使用。这意味着 Trait 可以被用于定义多个类型所共享的行为，而不是只能用于单个类型。

在下面的代码中，我们将为 AnimalBehavior Trait 添加一个泛型类型 T。这意味着 AnimalBehavior Trait 的方法可以被用于任何类型 T：

trait AnimalBehavior<T> {
    fn move_to(&self, x: u8, y: u8);
    fn make_sound(&self);
    fn eat(&self, food: T);
}

在上面的代码中，我们为 AnimalBehavior Trait 添加了一个泛型类型 T，并为 move_to 和 make_sound 方法提供了默认实现。我们还添加了一个新的方法 eat，该方法接受一个类型为 T 的参数 food。

现在，我们可以创建一个 Animal 实例，并将其视为 AnimalBehavior Trait 的实现。我们还可以创建一个名为 food 的变量，并将其传递给 AnimalBehavior Trait 中的 eat 方法：

fn main() {
    let animal = Animal {
        name: String::from("Tiger"),
        age: 3,
    };
    let animal_behavior: &dyn AnimalBehavior<&str> = &animal;
    let food = "meat";
    animal_behavior.move_to(10, 20);
    animal_behavior.make_sound();
    animal_behavior.eat(food);
}

在上面的代码中，我们创建了一个 Animal 实例，并将其视为 AnimalBehavior Trait 的实现。我们还定义了一个名为 animal_behavior 的变量，该变量是一个指向 AnimalBehavior Trait 的引用，并使用 &str 类型作为泛型参数。最后，我们创建了一个名为 food 的变量，并将其传递给 animal_behavior 的 eat 方法。

Trait 的 where 子句

Trait 可以包含 where 子句，该子句可以用于限制泛型类型的范围。where 子句通常用于限制泛型类型必须实现的 Trait。

在下面的代码中，我们将为 AnimalBehavior Trait 添加一个 where 子句，该子句要求泛型类型必须实现 Display Trait：

use std::fmt::Display;

trait AnimalBehavior<T>
where
    T: Display,
{
    fn move_to(&self, x: u8, y: u8);
    fn make_sound(&self);
    fn eat(&self, food: T);
}

在上面的代码中，我们为 AnimalBehavior Trait 添加了一个 where 子句，该子句要求泛型类型必须实现 Display Trait。这意味着我们可以在 AnimalBehavior Trait 的 eat 方法中使用 T 类型的 to_string 方法。

fn main() {
    let animal = Animal {
        name: String::from("Tiger"),
        age: 3,
    };
    let animal_behavior: &dyn AnimalBehavior<String> = &animal;
    let food = String::from("meat");
    animal_behavior.move_to(10, 20);
    animal_behavior.make_sound();
    animal_behavior.eat(food);
}

在上面的代码中，我们创建了一个 Animal 实例，并将其视为 AnimalBehavior Trait 的实现。我们还定义了一个名为 animal_behavior 的变量，该变量是一个指向 AnimalBehavior Trait 的引用，并使用 String 类型作为泛型参数。最后，我们创建了一个名为 food 的变量，并将其传递给 animal_behavior 的 eat 方法。

Trait 的继承

Trait 可以继承其他 Trait。这意味着一个 Trait 可以从另一个 Trait 继承方法。

在下面的代码中，我们将为 AnimalBehavior Trait 添加一个继承自 Clone Trait 的子 Trait，称为 CloneAnimalBehavior Trait：

trait CloneAnimalBehavior<T>: AnimalBehavior<T> + Clone
where
    T: Display + Clone,
{
    fn clone_animal(&self) -> Self;
}

在上面的代码中，我们定义了一个 CloneAnimalBehavior Trait，该 Trait 继承自 AnimalBehavior Trait 和 Clone Trait。我们还为 CloneAnimalBehavior Trait 添加了一个新的方法 clone_animal，该方法返回一个 Self 类型的实例。

现在，我们可以让 Animal 结构体实现 CloneAnimalBehavior Trait：

impl<T> CloneAnimalBehavior<T> for Animal
where
    T: Display + Clone,
{
    fn clone_animal(&self) -> Self {
        Animal {
            name: self.name.clone(),
            age: self.age.clone(),
        }
    }
}

在上面的代码中，我们使用 impl 关键字为 Animal 结构体实现 CloneAnimalBehavior Trait。我们为 clone_animal 方法提供了自己的实现，该方法返回一个 Animal 结构体的克隆实例。

现在，我们可以创建一个 Animal 实例，并将其视为 CloneAnimalBehavior Trait 的实现。然后，我们可以调用 CloneAnimalBehavior Trait 中定义的方法：

fn main() {
    let animal = Animal {
        name: String::from("Tiger"),
        age: 3,
    };
    let clone_animal_behavior: &dyn CloneAnimalBehavior<String> = &animal;
    let cloned_animal = clone_animal_behavior.clone_animal();
    println!(
        "Cloned animal name: {}, age: {}",
        cloned_animal.name, cloned_animal.age
    );
}

在上面的代码中，我们创建了一个 Animal 实例，并将其视为 CloneAnimalBehavior Trait 的实现。我们还定义了一个名为 clone_animal_behavior 的变量，该变量是一个指向 CloneAnimalBehavior Trait 的引用，并使用 String 类型作为泛型参数。最后，我们调用了 clone_animal_behavior 的 clone_animal 方法，并打印了克隆后的 Animal 实例的 name 和 age 属性。

总结

在本教程中，我们学习了如何使用 Trait 来定义方法集合，并将其用于实现 Animal 的行为。我们还学习了如何使用 Trait 的默认实现、泛型、where 子句和继承。Trait 是 Rust 中非常重要的机制，它可以使代码更加灵活和可复用。

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。欢迎转载、使用、重新发布，但务必保留文章署名 TinyZ Zzh （包含链接： https://tinyzzh.github.io ），不得用于商业目的，基于本文修改后的作品务必以相同的许可发布。如有任何疑问，请与我联系 (tinyzzh815@gmail.com) 。

TinyZ Zzh

专注于高并发服务器、网络游戏相关(Java、PHP、Unity3D、Unreal Engine等)技术，热爱游戏事业, 正在努力实现自我价值当中。

Rust语言从入门到精通系列 - Trait 特征

Animal 结构体

使用 Trait 实现 Animal 行为

Trait 的泛型

Trait 的 where 子句

Trait 的继承

总结

TinyZ Zzh

最新文章

评论

Rust语言从入门到精通系列 - Trait 特征

Animal 结构体

使用 Trait 实现 Animal 行为

Trait 的泛型

Trait 的 where 子句

Trait 的继承

总结

TinyZ Zzh

最 新 文 章

Newsletter

评论

最新文章