我们在trait中定义了一个成员方法，代码如下：

trait Shape {fn area(&self) -> f64;}

所有的trait中都有一个隐藏的类型Self（大写S），代表当前实现了此trait的具体类型。trait中定义的函数也可以称作关联函数（Associated Function）。函数的第一个参数如果是Self相关的类型，且命名为self（小写s），这个参数就可以被称为receiver（接收者）。具有receiver参数的函数称为“方法”（Method），可以通过变量实例使用小数点来调用。没有receiver参数的函数称为“静态函数”（Static Function），可以通过类型加双冒号“::”的方式来调用。在Rust中，函数和方法没有本质区别。

Rust中的Self（大写S）和self（小写s）都是关键字，Self的是类型名，self是变量名。请大家一定注意区分。self参数同样也可以指定类型，当然这个类型是有限制的，必须是包装在Self类型之上的类型。对于第一个self参数，常见的类型有self:Self、self:&Self、self:&mut Self等。对于以上这些类型，Rust提供了一种简化的写法，我们可以将参数简写为self、&self、&mut self。self参数只能用在第一个参数的位置。请注意，“变量self”和“类型Self”的大小写不同。比如：

trait T {fn method1(self: Self);fn method2(self: &Self);fn method3(self: &mut Self);}

这段代码和下面的写法是完全一样的：

trait T {fn method1(self);fn method2(&self);fn method3(&mut self);}

我们可以为某些具体类型实现（impl）这个Shape trait。假如有一个结构体类型Circle，它实现了这个特质，代码如下：

struct Circle {radius: f64,}impl Shape for Circle {// Self的类型是Circle// self的类型是&Self，即&Circlefn area(&self) -> f64 {// 访问成员变量，需要用self.radiusstd::f64::consts::PI * self.radius * self.radius}}fn main() {let c = Circle { radius : 2f64};// 第一个参数名字是self，可以使用小数点语法调用println!("The area is {}", c.area());}

另外，针对一个类型，可以直接通过关键字impl给该类型定义成员方法，且无须trait名字。    比如：

impl Circle {fn get_radius(&self) -> f64 { self.radius }}

我们可以把这段代码看作为Circle类型定义了一个匿名的trait。用这种方式定义的方法叫作这个类型的“内在方法”（Inherent Methods）。

trait中可以包含方法的默认实现。如果这个方法在trait中已经有了方法体，那么在针对具体类型实现的时候，就可以选择不用重写。当然，如果需要针对特殊类型进行特殊处理，也可以选择重新实现。比如，在标准库中，迭代器（Iterator）这个trait中就包含10多个方法，但是，其中只有fn next(&mut self)- >OptionSelf::Item是没有默认实现的。其他的方法均有其默认实现，在实现迭代器的时候只需挑选需要重写的方法来实现即可。

self参数甚至可以是Box指针类型self:Box。另外，目前Rust设计组也在考虑让self变量的类型放得更宽，允许更多的自定义类型作为receiver，比如MyType。例如下面的代码：

trait Shape {fn area(self: Box<Self>) -> f64;}struct Circle {radius: f64,}impl Shape for Circle {// Self的类型就是Circle// self的类型是Box<Self>，即Box<Circle>fn area(self : Box<Self>) -> f64 {// 访问成员变量，需要用self.radiusstd::f64::consts::PI * self.radius * self.radius}}fn main() {let c = Circle { radius : 2f64};// 编译错误// c.area();let b = Box::new(Circle {radius : 4f64});// 编译正确b.area();}

impl的对象甚至可以是trait。示例如下：

trait Shape {fn area(&self) -> f64;}trait Round {fn get_radius(&self) -> f64;}struct Circle {radius: f64,}impl Round for Circle {fn get_radius(&self) -> f64 { self.radius }}impl Trait for Trait impl Shape for Round {//为满足T:Round具体类型增加一个成员方法fn area(&self) -> f64 {std::f64::consts::PI * self.get_radius() * self.get_radius()}   }fn main() {let c = Circle { radius : 2f64};// 编译错误// c.area();let b = Box::new(Circle {radius : 4f64}) as Box<Round>;// 编译正确b.area();}

impl Shape for Round和impl<T:Round>Shape for T是不一样的。在前一种写法中，self是&Round类型，它是一个指向trait的指针，即trait Object。而在后一种写法中，self是&T类型，是具体类型。前一种写法是为trait Object增加一个成员方法，而后一种写法是为所有满足T:Round的具体类型增加一个成员方法。所以上面的示例中，我们只能在构造trait Object之后才能调用area()成员方法。

impl Shape for Round这种写法确实很让初学者纠结，Round既是trait又是Type。将来trait Object的语法会被要求加上dyn关键字。

没有receiver参数的方法（第一个参数不是self参数的方法）称作静态方法。静态方法可以通过Type::FunctionName()的方式调用。需要注意的是，即便第一个参数是Self相关类型，只要变量名字 不是self，就不能使用小数点的语法调用函数。

struct T(i32);impl T {// 这是一个静态方法fn func(this: &Self) {println!{"value {}", this.0};}}fn main() {let x = T(42);// x.func(); 小数点方式调用是不合法的T::func(&x);}

在标准库中就有一些这样的例子。Box的一系列方法Box:: into_raw(b:Self)Box::leak(b:Self)，以及Rc的一系列方法 Rc::try_unwrap(this:Self)Rc::downgrade(this:&Self)都是这种情况。它们的receiver不是self关键字，这样设计的目的是强制用户用Rc::downgrade(&obj)的形式调用，而禁止用obj.downgrade()的形式调用。这样源码表达出来的意思更清晰，不会因为Rc里面的成员方法和T里面的成员方法重名而造成误解。

trait中也可以定义静态函数。下面以标准库中的std::default:: Default trait为例介绍静态函数的相关用法：

pub trait Default {fn default() -> Self;}

上面这个trait中包含一个default()函数，它是一个无参数的函数，返回的类型是实现该trait的具体类型。Rust中没有构造函数的概念。Default trait实际上可以看作一个针对无参数构造函数的统一抽象。比如在标准库中，Vec::default()就是一个普通的静态函数。

impl<T> Default for Vec<T> {fn default() -> Vec<T> {Vec::new()}}

跟C++相比，在Rust中，定义静态函数没必要使用static关键字，因为它把self参数显式地在参数列表中列出来了。作为对比，C++里面的成员方法默认可以访问this指针，因此它需要用static关键字来标记静态方法。Rust不采取这个设计，主要原因是self参数的类型变化太多，不同写法的语义差别很大，选择显式声明self参数更方便指定它的类型。

我们还可以利用trait给其他的类型添加成员方法，哪怕这个类型不是我们自己写的。比如，可以为内置类型i32添加一个方法：

trait Double {fn double(&self) -> Self;}impl Double for i32 {fn double(&self) -> i32 { *self * 2 }}fn main() {// 可以像成员方法一样调用let x : i32 = 10.double();println!("{}", x);}

哪怕这个类型不是在当前 的项目中声明的，依然可以为它增加一些成员方法。但也不是随便就可以这么做，Rust对此有一个规定：在声明trait和impltraitl的时候，Rust规定了Coherence Rule（一致性规则）或称为Orphan Rule（孤儿规则）：imp块要么与trait的声明在同一个crate中，要么与类型的声明在同一个crate中。

这是有意设计的。如果我们在使用其他crate的时候，强行把它们“拉郎配”，是会制造出Bug的。比如说，我们写了一个程序，引用了外部库lib1和lib2，lib1中声明了一个trait T，lib2中声明了一个struct S，我们不能在自己的程序中针对S实现T。这也意味着，上游开发者在给别人写库的时候，尤其要注意，一些比较常见的标准库中的trait，如Display Debug ToString Default等，应该尽可能提供好。否则，使用这个库的下游开发者是没办法帮我们实现这些trait的。同理，如果是匿名impl，那么这个impl块必须与类型本身存在于同一个crate中。

Rust是一种用户可以对内存有精确控制能力的强类型语言。我们可以自由指定一个变量是在栈里面还是在堆里面，变量和指针也是不同的类型。类型是有大小（Size）的。有些类型的大小在编译阶段就可以确定，有些类型的大小在编译阶段无法确定。目前版本的Rust规定，在函数参数传递、返回值传递等地方，都要求这个类型在编译阶段有确定的大小。否则，编译器就不知道该如何生成代码了。而trait本身既不是具体类型，也不是指针类型，它只是定义了针对类型的、抽象的“约束”。不同的类型可以实现同一个trait，满足同一个trait的类型可能具有不同的大小。因此，trait在编译阶段没有固定大小，目前我们不能直接使用trait作为实例变量、参数、返回值。比如：

let x: Shape = Circle::new();             // Shape不能做局部变量的类型fn use_shape(arg : Shape) {}               // Shape不能直接做参数的类型fn ret_shape() -> Shape {}                // Shape不能直接做返回值的类型

这样的写法是错误的，请一定要记住。trait的大小在编译阶段是不固定的，需要写成dynShape形式，即编译的时候把不确定大小的内容通过胖指针来代替，而指针在编译期是确定的。胖指针包含一个指向数据的指针和数据的长度信息，在Rust中，数组、切片、trait对象等都是胖指针。