[易学易懂系列|rustlang语言|零基础|快速入门|(14)]

Posted gyc567

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[易学易懂系列|rustlang语言|零基础|快速入门|(14)]相关的知识,希望对你有一定的参考价值。

[易学易懂系列|rustlang语言|零基础|快速入门|(14)]

有意思的基础知识

Impls & Traits实现与特征

我之前说到的struct结构体,其实就类似于面向对象语言中的类class。

但这个struct,并没有定义方法或函数。

那要怎么办呢?

Rust用关键词impls(实现)来定义struct和enum的方法或函数。

而trait(特征),类似于面向对象语言中的接口interface。

特征,是用来定义要实现的方法,一个类型可以有多个特征。特征可以有默认实现函数,这个默认函数可以在运行时重写。

我们来看看代码:

1.没有trait特征的impl实现:

struct Player {
    first_name: String,
    last_name: String,
}

impl Player {
    
    fn full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }
}

fn main() {
    let player_1 = Player {
        first_name: "Rafael".to_string(),
        last_name: "Nadal".to_string(),
    };

    println!("Player 01: {}", player_1.full_name());
}

// ?? Implementation must appear in the same crate as the self type

// ?? And also in Rust, new traits can be implemented for existing types even for types like i8, f64 and etc.
// Same way existing traits can be implemented for new types you are creating.
// But we can not implement existing traits into existing types.

我们来看看上面的代码,其中这段代码,跟之前的函数,有点不一样:

impl Player {
    fn full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }
}

这里第一个参数:&self,它代表什么意思呢?

&self代表结构体Player的实例。

当然这里的第一个参数,可以是:self, &self, 或&mut self

self是一个栈内值 。

&self是一个引用值(不可变),数据在堆heap里分配空间。

&mut self是一个可变的引用值,数据在堆heap里分配空间

所以通过,self.first_name, self.last_name,我们就可以访问结构体的属性first_name,last_name。

这里的impl 代码块代表结构体Player的具体实现方法,impl后面的类型,必须是Player。

1.特征(trait)的实现方式:

struct Player {
    first_name: String,
    last_name: String,
}

trait FullName {
    fn full_name(&self) -> String;
}

impl FullName for Player {
    fn full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }
}

fn main() {
    let player_2 = Player {
        first_name: "Roger".to_string(),
        last_name: "Federer".to_string(),
    };

    println!("Player 02: {}", player_2.full_name());
}

// ?? Other than functions, traits can contain constants and types.

我们可以看到上面代码中加了一个特征的定义,代码可读性好很多:

trait FullName {
    fn full_name(&self) -> String;
}

好,现在我们加上默认函数(default method):

struct Player {
    first_name: String,
    last_name: String,
}
trait FullName {
    fn full_name(&self) -> String;
    fn baz(&self) { println!("We called baz.");// 默认函数
}
impl FullName for Player {
    fn full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }
}

fn main() {
    let player_2 = Player {
        first_name: "Roger".to_string(),
        last_name: "Federer".to_string(),
    };

    println!("Player 02: {}", player_2.full_name());
    player_2.baz();//直接调用默认函数
}

3.关联函数(Associated functions):

请看如下例子:

struct Player {
    first_name: String,
    last_name: String,
}

impl Player {
    fn new(first_name: String, last_name: String) -> Player {
        Player {
            first_name : first_name,
            last_name : last_name,
        }
    }

    fn full_name(&self) -> String {
        format!("{} {}", self.first_name, self.last_name)
    }
}

fn main() {
    let player_name = Player::new("Serena".to_string(), "Williams".to_string()).full_name();
    println!("Player: {}", player_name);
}

// We have used :: notation for `new()` and . notation for `full_name()`

// ?? Also in here, instead of using new() and full_name() separately as two expressions, 
// we can use Method Chaining. ex. `player.add_points(2).get_point_count();`

上面代码,我们看到多了一个函数new(注意这个函数的参数,不用self关键字),我们看到这个new函数跟java中的构造函数很像。

这个函数可以不通过创建对象实例,就可以直接调用,一般用双冒号::,如:Player::new。

在Rust,我们叫这种函数为:关联函数(Associated functions)。

我们再来看看特征的其他用法:

带泛型的特征:

trait From<T> {
    fn from(T) -> Self;
}
    impl From<u8> for u16 {
        //...
    }
    impl From<u8> for u32{
        //...
    }

// Should specify after the trait name like generic functions

带继承关系的特征:

trait Person {
    fn full_name(&self) -> String;
}
trait Expat{
    fn tax(&self)->f64;
}

    trait Employee : Person { // Employee inherits from person trait
      fn job_title(&self) -> String;
    }

    trait ExpatEmployee : Employee + Expat { // ExpatEmployee inherits from Employee and Expat traits
      fn additional_tax(&self) -> f64;
    }

特征对象:

trait GetSound {
    fn get_sound(&self) -> String;
}

struct Cat {
    sound: String,
}
    impl GetSound for Cat {
        fn get_sound(&self) -> String {
            self.sound.clone()
        }
    }

struct Bell {
    sound: String,
}
    impl GetSound for Bell {
        fn get_sound(&self) -> String {
            self.sound.clone()
        }
    }


fn make_sound<T: GetSound>(t: &T) {
    println!("{}!", t.get_sound())
}

fn main() {
    let kitty = Cat { sound: "Meow".to_string() };
    let the_bell = Bell { sound: "Ding Dong".to_string() };

    make_sound(&kitty); // Meow!
    make_sound(&the_bell); // Ding Dong!
}

上面的代码我们可以看到,Rust实现多态,可以用动态分发的机制,所谓动态分发,就是在运行时,才决定真正的实现,并加载这个实现。

以上,希望对你有用。

如果遇到什么问题,欢迎加入:rust新手群,在这里我可以提供一些简单的帮助,加微信:360369487,注明:博客园+rust

参考:https://doc.rust-lang.org/rust-by-example/generics/impl.html

? https://learning-rust.github.io/docs/b5.impls_and_traits.html

? https://doc.rust-lang.org/book/ch05-03-method-syntax.html

以上是关于[易学易懂系列|rustlang语言|零基础|快速入门|(14)]的主要内容,如果未能解决你的问题,请参考以下文章

[易学易懂系列|rustlang语言|零基础|快速入门|]

[易学易懂系列|rustlang语言|零基础|快速入门|(11)]

[易学易懂系列|rustlang语言|零基础|快速入门|(14)]

[易学易懂系列|rustlang语言|零基础|快速入门|(12)]

[易学易懂系列|rustlang语言|零基础|快速入门|(13)]

[易学易懂系列|rustlang语言|零基础|快速入门|(21)|智能指针]