java implement 泛型_22-Rust泛型

泛型 就是可以在运行时指定数据类型的机制。

泛型 最大的好处就是一套代码可以应用于多种类型。比如我们的 向量，可以是整型向量，也可以是字符串向量。

泛型 既能保证数据安全和类型安全，同时还能减少代码量。所以，现代语言，没有泛型简直就是鸡肋。

嘿，说的就是你，隔壁的 XX 语言。

Rust 语言中的泛型主要包含 泛型集合、泛型结构体、泛型函数、范型枚举 和 特质 几个方面。

22.1 Rust 语言中的泛型

Rust 使用使用 语法来实现泛型的东西指定数据类型。 其中 T 可以是任意数据类型。

例如下面的两个类型

age: i32

age: String

使用泛型，则可以直接声明为

age:T

然后在使用过程中指定 T 的类型为 i32 或 String 即可。

22.2 泛型集合

日常使用过程中，我们最常见的泛型应用莫过于 集合 ( collection ) 了。

比如我们一直在使用的向量 Vec。它可以是一个字符串向量，也可以是一个整形向量。

下面的代码，我们声明了一个整型向量

fn main(){letmutvector_integer: Vec=vec![20,30];vector_integer.push(40);println!("{:?}",vector_integer);}

编译运行以上 Rust 范例，输出结果如下

[20, 30, 40]

如果向整型向量传递一个非整型参数，则会报错

fn main(){letmutvector_integer: Vec=vec![20,30];vector_integer.push(40);vector_integer.push("hello");//error[E0308]: 类型不匹配println!("{:?}",vector_integer);}

上面的代码中可以看出，整型的向量只能添加整型的参数，如果尝试添加一个字符串参数则会报错。

从某些方面说，泛型 让集合更通用，也更安全。

22.3 泛型结构体

我们也可以把某个结构体声明为泛型的，泛型结构体 主要是结构体的成员类型可以是泛型。

泛型结构体的定义语法如下

struct struct_name{field:T,}

例如我们可以定义一个泛型结构体 Data，它只有一个成员 value，类型是一个泛型。

struct Data{value:T,}

把我们的泛型结构体语法和泛型结构体实例 Data 放在一起对比下，很容易区分泛型结构体和普通结构体的不同。

22.3.1 范例

下面的范例，我们使用了刚刚定义的泛型结构体 Data，演示了如何使用泛型结构体

fn main(){// 泛型为 i32lett:Data=Data{value:350};println!("value is :{} ",t.value);// 泛型为 Stringlett2:Data=Data{value:"Tom".to_string()};println!("value is :{} ",t2.value);}struct Data{value:T,}

编译运行以上 Rust 范例，输出结果如下

value is :350

value is :Tom

22.4 特质 Traits

Rust 语言中没有 类 ( class ) 这个概念，于是顺带把 接口 (interface ) 这个概念也取消了。

可是，没有了 接口 我们要如何证明两个结构体之间的关系呢 ？

为此，Rust 提供了 特质 Traits 这个蛋炒饭的概念。

说蛋炒饭，是因为很多语言都有特质这个概念。

Rust 提供了 特质 Traits 这个概念，用于跨多个结构体实现一组标准行为(方法)。

从某些方面来说，虽然 Rust 语言没有接口的概念，但 特质 Traits 实打实的就是接口啊。

22.4.1 特质的定义语法

Rust 语言提供了 trait 关键字用于定义 特质。

特质 其实就是一组方法原型。它的语法格式如下

traitsome_trait{// 没有任何实现的虚方法fn method1(&self);// 有具体实现的普通方法fn method2(&self){//方法的具体代码}}

从语法格式来看，特征可以包含具体方法(带实现的方法)或抽象方法(没有具体实现的方法)

如果想让某个方法的定义在实现了特质的结构体所共享，那么推荐使用具体方法。

如果想让某个方法的定义由实现了特质的结构体自己定义，那么推荐使用抽象方法。

即使某个方法是具体方法，结构体也可以对该方法进行重写。

22.4.2 实现特质 impl for

前面我们说过了，Rust 中的 特质 相当于其它语言的 接口 ( interface )。

其它语言，比如 Java 实现接口使用的是 implement 关键字。

但 Rust 却不这么做，而是提供了一个更加语义化的词组 impl for。

如果要为某个结构体 ( struct )实现某个特质，需要使用 impl for 语句。

impl 是 implement 的缩写。impl for 语义已经很明显了，就是为 xxx 实现 xxx 的意思。

impl for 语句的语法格式如下

implsome_traitforstructure_name{// 实现 method1() 的具体代码fn method1(&self){}}注意: 特质的方法是结构体的成员方法，因此第一个参数是 &self。

22.4.3 范例: impl for 的简单使用

下面的范例，我们首先定义了一个结构体 Book 和一个特质 Printable。

然后我们使用 impl for 语句为 Book 实现特质 Printable。

fn main(){//创建结构体 Book 的实例letb1=Book{id:1001,name:"Rust in Action"};b1.print();}//声明结构体struct Book{name:&'staticstr,id:u32

}// 声明特质traitPrintable{fn print(&self);}// 实现特质implPrintableforBook{fn print(&self){println!("Printing book with id:{} and name {}",self.id,self.name)}}

编译运行以上 Rust 范例，输出结果如下

Printing book with id:1001 and name Rust in Action

22.5 泛型函数

泛型也可以用在函数中，我们称使用了泛型的函数为 泛型函数。

泛型函数 主要是指 函数的参数 是泛型。注意: 泛型函数并不要求所有参数都是泛型，而是某个参数是泛型。

泛型函数的定义语法如下

fn function_name(param1:T,[other_params]){// 函数实现代码}

例如我们定义一个可以打印输出任意类型的泛型函数 print_pro

fn print_pro(t:T){println!("Inside print_pro generic function:");println!("{}",t);}

对比语法和范例，泛型函数的定义就很简单了。

22.5.1 范例

下面的范例我们使用刚刚定义的泛型函数 print_pro()，该函数会打印输出传递给它的参数。

传递的参数可以是实现了 Display 特质的任意类型。

usestd::fmt::Display;fn main(){print_pro(10asu8);print_pro(20asu16);print_pro("Hello TutorialsPoint");}fn print_pro(t:T){println!("Inside print_pro generic function:");println!("{}",t);}

编译运行以上 Rust 范例，输出结果如下

Inside print_pro generic function:

10

Inside print_pro generic function:

20

Inside print_pro generic function:

Hello TutorialsPoint