你还记得 impl 关键字吗，它用于调用一个函数的 methodsyntax
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
} 特征几乎都是相似的，除了我们用方法签名去定义一个特征,然后实现该结构的特征。如下面所示：
struct Circle {
x: f64,
y: f64,
radius: f64,
}
trait HasArea {
fn area(&self) -> f64;
}
impl HasArea for Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
} 如您所见，这个特征块和 impl 块非常相似，但我们不定义一个主体，只是定义一个类型签名。当我们 impl 一个特征时，我们使用 impl 特征项，而不仅仅是 impl 项。
我们可以使用特征约束泛型。思考下面这个函数，它没有编译，只给我们一个类似的错误：
fn print_area<T>(shape: T) {
println!("This shape has an area of {}", shape.area());
} Rust 可能会抱怨道：
error: type `T` does not implement any method in scope named `area`
因为 T 可以是任何类型，我们不能确保它实现了 area 的方法。但我们可以添加一个特征约束的泛型 T，确保它已经实现：
fn print_area<T: HasArea>(shape: T) {
println!("This shape has an area of {}", shape.area());
} 语法 < T:HasArea >意味着实现 HasArea 特征的任何类型。因为特征定义函数的类型签名，我们可以肯定，任何实现 HasArea 的类型都会有.area()方法。
这里有一个扩展的例子展示它是如何工作的：
trait HasArea {
fn area(&self) -> f64;
}
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl HasArea for Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
}
struct Square {
x: f64,
y: f64,
side: f64,
}
impl HasArea for Square {
fn area(&self) -> f64 {
self.side * self.side
}
}
fn print_area<T: HasArea>(shape: T) {
println!("This shape has an area of {}", shape.area());
}
fn main() {
let c = Circle {
x: 0.0f64,
y: 0.0f64,
radius: 1.0f64,
};
let s = Square {
x: 0.0f64,
y: 0.0f64,
side: 1.0f64,
};
print_area(c);
print_area(s);
} 这个程序输出：
This shape has an area of 3.141593
This shape has an area of 1
如您所见，print_area 现在是通用的，同时也确保我们通过了正确的类型。如果我们通过一个错误的类型：
print_area(5);
我们会得到一个编译错误：
error: failed to find an implementation of trait main::HasArea for int
到目前为止，我们只添加特征实现结构，但您可以实现任何类型的特征。所以从技术上讲，我们可以为 i32 实现 HasArea：
trait HasArea {
fn area(&self) -> f64;
}
impl HasArea for i32 {
fn area(&self) -> f64 {
println!("this is silly");
*self as f64
}
}
5.area(); 我们一般认为用这种基本类型来实现方法是一种不够好的风格，即便这种实现方法是可行的。
这可能看起来比较粗糙，但是有两个其他的限制来控制特征的实现,防止失控。首先，如果特征不是在你的范围中定义的,那么不适用。下面是一个例子：标准库提供了编写特征，这个特征给文件的输入输出增加了额外的功能。默认情况下，文件并不会有自己的方法：
let mut f = std::fs::File::open("foo.txt").ok().expect("Couldn’t open foo.txt");
let result = f.write("whatever".as_bytes()); 这里有一个错误：
error: type `std::fs::File` does not implement any method in scope named `write`
let result = f.write(b"whatever");
我们需要先使用编写特征：
use std::io::Write;
let mut f = std::fs::File::open("foo.txt").ok().expect("Couldn’t open foo.txt");
let result = f.write("whatever".as_bytes());
此时编译没有出现错误。
这意味着，即使有人做了坏事比如向 int 添加方法，也不会影响你，除非你使用这个特征。
实现特征还有其他限制。你为特征或类型所写的 impl 必须由你来定义。所以,我们可以实现 HasArea 类型等，因为 HasArea 是我们的代码。但是如果我们试图实现浮点型,它是 Rust 为 i32 所提供的特征，是不可能的，因为无论特征还是类型都不在我们的代码里面。
最后关于特征：通用函数特征的捆绑使用 “monomorphization”(mono:一个，morph:形式),所以他们都是静态调用。那意味着什么呢?到特征对象那一章查看更多细节。
如您所看到的，您可以绑定特征与一个泛型的类型参数：
fn foo<T: Clone>(x: T) {
x.clone();
} 如果你需要多个绑定，您可以使用+：
use std::fmt::Debug;
fn foo<T: Clone + Debug>(x: T) {
x.clone();
println!("{:?}", x);
}
T 现在需要复制以及调试。
只用少数泛型和少量的特征界限来写函数并不是太糟糕，但随着数量的增加，语法变得越来越糟糕：
use std::fmt::Debug;
fn foo<T: Clone, K: Clone + Debug>(x: T, y: K) {
x.clone();
y.clone();
println!("{:?}", y);
}
println !(“{:?}”,y);
}
函数的名称是在最左边，参数列表在最右边。边界就以这种方式存在。
Rust 已经有了解决方法，这就是所谓的“where 子句”：
use std::fmt::Debug;
fn foo<T: Clone, K: Clone + Debug>(x: T, y: K) {
x.clone();
y.clone();
println!("{:?}", y);
}
fn bar<T, K>(x: T, y: K) where T: Clone, K: Clone + Debug {
x.clone();
y.clone();
println!("{:?}", y);
}
fn main() {
foo("Hello", "world");
bar("Hello", "workd");
}
foo()使用我们之前讲解的语法，bar()使用一个 where 子句。所有你需要做的就是定义类型参数时不要定义边界，然后在参数列表之后添加 where 语句。对于更长的列表，可以添加空格：
use std::fmt::Debug;
fn bar<T, K>(x: T, y: K)
where T: Clone,
K: Clone + Debug {
x.clone();
y.clone();
println!("{:?}", y);
}
这种灵活性可以使复杂情况变得清晰。
Where 语句也比简单的语法更加强大。例如：
trait ConvertTo<Output> {
fn convert(&self) -> Output;
}
impl ConvertTo<i64> for i32 {
fn convert(&self) -> i64 { *self as i64 }
}
// can be called with T == i32
fn normal<T: ConvertTo<i64>>(x: &T) -> i64 {
x.convert()
}
// can be called with T == i64
fn inverse<T>() -> T
// this is using ConvertTo as if it were "ConvertFrom<i32>"
where i32: ConvertTo<T> {
1i32.convert()
} 这个例子展了示 where 子句的附加特性：它们允许范围内的左边可以是一个任意的类型(在这里是 i32)，而不只是一个普通的类型参数(如 T)。
我们的最后一个特征的特性应包括：默认的方法。举个简单的例子更容易说明：
trait Foo {
fn bar(&self);
fn baz(&self) { println!("We called baz."); }
} Foo 特征的实现者需要实现 bar()方法，但是他们不需要实现 baz()。他们会得到这种默认行为。如果他们这么选择的话就可以覆盖默认的情形：
struct UseDefault;
impl Foo for UseDefault {
fn bar(&self) { println!("We called bar."); }
}
struct OverrideDefault;
impl Foo for OverrideDefault {
fn bar(&self) { println!("We called bar."); }
fn baz(&self) { println!("Override baz!"); }
}
let default = UseDefault;
default.baz(); // prints "We called baz."
let over = OverrideDefault;
over.baz(); // prints "Override baz!"
⇱
有时，想要实现某个特征需要先实现另一个特征：
trait Foo {
fn foo(&self);
}
trait FooBar : Foo {
fn foobar(&self);
}
FooBar的实现者也要实现Foo,像这样:
struct Baz;
impl Foo for Baz {
fn foo(&self) { println!("foo"); }
}
impl FooBar for Baz {
fn foobar(&self) { println!("foobar"); }
} 如果我们忘记实现 Foo，Rust 会告诉我们：
error: the trait `main::Foo` is not implemented for the type `main::Baz` [E027]