许多人会想问:Rust 是面向对象的编程语言吗?答案可以为是,也可以为不是,端看问这个问题的人对于「面向对象编程语言」定义的严格程度。Rust 编程语言有结构体,而且可以使用 impl 关键字来替结构体实作特性和方法,甚至可以使用 pub 关键字来设置成员的访问权限,这难道不就是面向对象编程语言吗?也许吧!但别忘了,Rust 编程语言本身也提供了基本数据型态,我们先不论程序的难易度,其实可以只使用基本数据型态来完成一个可以运行的程序,让这个程序完全没有任何「对象」的概念,可是这样的话,Rust 还是属于面向对象编程语言吗?
精确一点来说的话,Rust 是以命令式编程(imperative programming)为主,支持函数式编程(functional programming)和面向对象编程(object-oriented programming)的语言。
面向对象程序有封装(encapsulation)、继承(inheritance)以及多态(polymorphism)的概念,这些当然也存在于 Rust 编程语言中,而我们在之前的章节也早就已经学过这些了,来整理并复习一下吧!
封装
面向对象的封装可以将每个对象的属性、函数、方法、类型等等项目区分访问权限。Rust 编程语言的访问权限只有分为公开的(public)和私有的(private)。有加 pub 关键字的项目就是公开的项目;没有加 pub 关键字的项目就是私有的项目。
举例来说:
pub struct AveragedCollection {
list: Vec<i32>,
average: f64,
}
impl AveragedCollection {
pub fn add(&mut self, value: i32) {
self.list.push(value);
self.update_average();
}
pub fn remove(&mut self) -> Option<i32> {
let result = self.list.pop();
match result {
Some(value) => {
self.update_average();
Some(value)
}
None => None,
}
}
pub fn average(&self) -> f64 {
self.average
}
fn update_average(&mut self) {
let total: i32 = self.list.iter().sum();
self.average = total as f64 / self.list.len() as f64;
}
}
AveragedCollection 结构体可以作为一个对象的「类别」(class)来看,其 UML 类别图表如下:
单纯只加上 pub 关键字的项目可以一直被向上公开,如果只是要将项目公开到模块外,但还是限制在同一个 crate 内使用的话,需使用 pub(crate) 关键字。其它还有限制在父模块下公开,要使用 pub(super);限制在指定路径下公开,要使用 pub(in 路径)。
继承
面向对象的继承,可以让一个对象类别 A 去继承某个对象类别 B 的定义,如此一来对象类别 A 可以在不重新实作程序的情况下直接使用对象类别 B 定义好的功能,甚至也可以使用不同的程序来实作对象类别 B 的定义,也能让对象类别 A 定义出新的对象类别 B 所没有的项目。
Rust 的结构体不能直接继承另一个结构体,只能使用特性(trait),来完成类似继承的动作。
举例来说:
// TODO -----Traits-----
trait CanTakePictures {
fn get_resolution(&self) -> (i32, i32);
fn take_picture(&self) {
let resolution = self.get_resolution();
// do something
}
}
trait CanMakePhoneCalls {
fn call(&self) {
// do something
}
}
trait Product {
fn get_price(&self) -> f64;
fn get_brand(&self) -> &str;
}
// TODO -----Combined Traits-----
trait CellPhone: Product + CanMakePhoneCalls {}
trait Camera: Product + CanTakePictures {}
// TODO -----Structs-----
struct StupidPhone {
price: f64,
brand: String,
}
struct SmartPhone {
price: f64,
brand: String,
resolution: (i32, i32),
}
struct DigitalCamera {
price: f64,
brand: String,
resolution: (i32, i32),
}
// TODO -----StupidPhone-----
impl CellPhone for StupidPhone {}
impl Product for StupidPhone {
fn get_price(&self) -> f64 {
self.price
}
fn get_brand(&self) -> &str {
&self.brand
}
}
impl CanMakePhoneCalls for StupidPhone {}
// TODO -----SmartPhone-----
impl CellPhone for SmartPhone {}
impl Product for SmartPhone {
fn get_price(&self) -> f64 {
self.price
}
fn get_brand(&self) -> &str {
&self.brand
}
}
impl CanMakePhoneCalls for SmartPhone {}
impl CanTakePictures for SmartPhone {
fn get_resolution(&self) -> (i32, i32) {
self.resolution
}
}
// TODO -----DigitalCamera-----
impl Camera for DigitalCamera {}
impl Product for DigitalCamera {
fn get_price(&self) -> f64 {
self.price
}
fn get_brand(&self) -> &str {
&self.brand
}
}
impl CanTakePictures for DigitalCamera {
fn get_resolution(&self) -> (i32, i32) {
self.resolution
}
}
UML 类别图表如下:
在使用 trait 关键字定义特性时,我们可以在定义好的特性名称后面加上冒号 : 和其它多个特性名称(以加号 + 分隔),即可决定该特性要继承哪些特性。
多态
面向对象的多态,可以将某类别的父类别作为该类别对象的类型。继续使用以上继承的例子,SmartPhone 结构实体的类型可以是 SmartPhone,也可以是 CellPhone、Product、CanMakePhoneCalls 或是 CanTakePictures。
举例来说,如果我们替继承的例子加上 main 函数:
fn main() {
let asus_zf5z =
SmartPhone { price: 16990f64, brand: String::from("ASUS"), resolution: (4000, 3000) };
print_price(&asus_zf5z);
}
fn print_price(product: &SmartPhone) {
println!("{}", product.get_price());
}
print_price 函数使用了 Product 特性所定义的 get_price 方法。我们也可以将 print_price 函数的 product 参数的类型 &SmartPhone 改为 &dyn CellPhone 或是 &dyn Product,程序也还是能够成功编译并运行,这就是多态的概念。
动态调度(Dynamic dispatch)
特性类型无法直接以一般非参考类型来进行传递,这是因为编译器并不能知道该特性的实体实际在内存中会占用多少大小。举例来说:
fn main() {
let asus_zf5z =
SmartPhone { price: 16990f64, brand: String::from("ASUS"), resolution: (4000, 3000) };
print_price_smartphone(asus_zf5z);
}
fn print_price_smartphone(product: SmartPhone) {
println!("{}", product.get_price());
}
fn print_price_product(product: dyn Product) {
println!("{}", product.get_price());
}
print_price_smartphone 函数可以编译成功,因为 product 参数为 SmartPhone 结构体类型,在编译阶段即可知道 SmartPhone 结构实体的大小有多少。而 print_price_product 函数会编译失败,因为 Product 特性只是一个抽象的类型,在目前这个程序中,SmartPhone、StupidPhone、DigitalCamera 都有实作 Product 特性,编译器无法确定究竟要分配多大的内存空间给 product 参数,也不知道该值究竟是哪个结构体的实体,无法决定在调用方法时要跳去运行哪边的程序。
为了要解决这个问题,我们将特性实体的参考,以及指着该特性实体的智能型指针实体,称为「特性对象」(Trait Object)。举例来说:
fn main() {
let asus_zf5z: &dyn Product =
&(SmartPhone { price: 16990f64, brand: String::from("ASUS"), resolution: (4000, 3000) });
let lg_kx300: Box<dyn Product> =
Box::new(StupidPhone { price: 3000f64, brand: String::from("LG") });
}
以上程序,asus_zf5z 变量和 lg_kx300 变量都是特性对象。
特性对象非常方便,不会让编译器不知道要分配多少空间给变量使用,而且也支持多态。举例来说:
fn main() {
let asus_zf5z: &dyn Product =
&(SmartPhone { price: 16990f64, brand: String::from("ASUS"), resolution: (4000, 3000) });
let lg_kx300: Box<dyn Product> =
Box::new(StupidPhone { price: 3000f64, brand: String::from("LG") });
print_price_reference(asus_zf5z);
print_price_box(lg_kx300);
}
fn print_price_reference(product: &dyn Product) {
println!("{}", product.get_price());
}
fn print_price_box(product: Box<dyn Product>) {
println!("{}", product.get_price());
}
以上程序 print_price_reference 函数直接使用 &dyn Product 来接受 asus_zf5z 这个特性对象,print_price_box 函数直接使用 Box<dyn Product> 来接受 lg_kx300 这个特性对象,程序在编译阶段只会去检查传入这两个函数的特性对象是否有实作 Product 特性,在程序运行阶段才去查找特性对象参考所指到的值究竟是哪个结构体的实体,这就是「动态调度」。
静态调度(Static dispatch)
除了使用特性的参考类型来传递结构实体之外,我们也可以使用泛型来做「静态调度」。「静态调度」相对于「动态调度」,在先前的章节有提到过,编译器在编译程序时会自动把有泛型定义的项目解开。举例来说:
fn main() {
let asus_zf5z =
SmartPhone { price: 16990f64, brand: String::from("ASUS"), resolution: (4000, 3000) };
let lg_kx300 = StupidPhone { price: 3000f64, brand: String::from("LG") };
print_price(asus_zf5z);
print_price(lg_kx300);
}
fn print_price<T: Product>(product: T) {
println!("{}", product.get_price());
}
编译器会将 print_price 函数的泛型定义解开为:
fn main() {
let asus_zf5z =
SmartPhone { price: 16990f64, brand: String::from("ASUS"), resolution: (4000, 3000) };
let lg_kx300 = StupidPhone { price: 3000f64, brand: String::from("LG") };
print_price_smartphone(asus_zf5z);
print_price_stupidphone(lg_kx300);
}
fn print_price_smartphone(product: SmartPhone) {
println!("{}", product.get_price());
}
fn print_price_stupidphone(product: StupidPhone) {
println!("{}", product.get_price());
}
如此一来,我们依然是使用结构体类型来传递结构体实体,因此程序在编译阶段就可以确定 product 参数要被分配的内存大小。
另外,相对于用于动态调度的 dyn 关键字,我们也可以使用 impl 关键字搭配特性类型来表示静态调度,代替泛型的语法。举例来说:
fn main() {
let asus_zf5z =
SmartPhone { price: 16990f64, brand: String::from("ASUS"), resolution: (4000, 3000) };
let lg_kx300 = StupidPhone { price: 3000f64, brand: String::from("LG") };
print_price(asus_zf5z);
print_price(lg_kx300);
}
fn print_price(product: impl Product) {
println!("{}", product.get_price());
}
不能作为特性对象使用的特性
只要特性或特性的父特性有符合下列情事之一的话,该特性就无法作为特性对象使用:
Self)。2. 方法有泛型类型的参数。
Rust 编程语言的标准函数库内置的 Clone 特性,正是一个拥有回传值的类型为自身类型(Self)的函数的特性。因此,如果将程序修改如下:
trait MyTrait: Clone {}
struct MyStructA {}
struct MyStructB {}
impl MyTrait for MyStructA {}
impl Clone for MyStructA {
fn clone(&self) -> MyStructA {
MyStructA {}
}
}
impl MyTrait for MyStructB {}
impl Clone for MyStructB {
fn clone(&self) -> MyStructB {
MyStructB {}
}
}
struct MyTraitVec {
vec: Vec<Box<dyn MyTrait>>,
}
程序就会编译失败。
以下程序也会编译失败:
trait MyTrait {
fn generic_method<T: std::fmt::Debug>(&self, a: T) {
println!("{a:?}");
}
}
struct MyStructA {}
struct MyStructB {}
impl MyTrait for MyStructA {}
impl MyTrait for MyStructB {}
struct MyTraitVec {
vec: Vec<Box<dyn MyTrait>>
}
究竟该不该面向对象?
Rust 虽然支持面向对象编程,但我们真的要坚持使用面向对象吗?我们用一个实际的应用来举例好了。现在我们要利用 Rust 编程语言实作一个博客发文系统,每篇文章在一开始创建的时候都是草稿,当草稿完成之后,在同意发布之前,必须要先进行检查的动作,且只有已发布的文章,才可以取得其文章内容。
我们可以用 Cargo 创建出一个新的 blog 程序项目,撰写出以下程序:
pub struct Post {
state: Option<Box<dyn State>>,
content: String,
}
impl Post {
pub fn new() -> Post {
Post { state: Some(Box::new(Draft {})), content: String::new() }
}
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn content(&self) -> &str {
self.state.as_ref().unwrap().content(&self)
}
pub fn request_review(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.request_review())
}
}
pub fn approve(&mut self) {
if let Some(s) = self.state.take() {
self.state = Some(s.approve())
}
}
}
trait State {
fn request_review(self: Box<Self>) -> Box<dyn State>;
fn approve(self: Box<Self>) -> Box<dyn State>;
fn content<'a>(&self, _post: &'a Post) -> &'a str {
""
}
}
struct Draft {}
impl State for Draft {
fn request_review(self: Box<Self>) -> Box<dyn State> {
Box::new(PendingReview {})
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
}
struct PendingReview {}
impl State for PendingReview {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
Box::new(Published {})
}
}
struct Published {}
impl State for Published {
fn request_review(self: Box<Self>) -> Box<dyn State> {
self
}
fn approve(self: Box<Self>) -> Box<dyn State> {
self
}
fn content<'a>(&self, post: &'a Post) -> &'a str {
&(post.content)
}
}
我们使用 Post 结构体来表示文章,content 字段为其文章内容,state 字段为其目前的状态。每个状态都是实作 State 特性的结构体,共有 Draft(草稿)、PendingReview(检查时期)、Published(已发布)这三种结构体。
这里比较需要注意到的地方是,程序第 16 行,使用 Option 枚举实体的 as_ref 方法,来将 Option<T> 转为 Option<&T>,如此一来就不会尝试夺取 Post 结构实体的 state 字段对于其值的拥有权,而造成编译失败。程序第 20 行和第 26 行,使用了 Option 枚举实体的 take 方法,就会转移这个 Option 枚举实体的拥有者,并将该 Option 枚举实体回传,原先 Option 枚举实体拥有者拥有的值会被改为 None。程序第 33 行和第 34 行,State 特性所定义的抽象 request_review 和 approve 方法,其第一个参数不是使用 &self,而是 self: Box<Self>,表示这个方法只能被用在当实体被 Box 智能型指针参考时,且在使用这个方法后,该实体的拥有者就会因拥有权被夺走而无法再被使用了。至于为什么要使用 Box 结构体?那是因为我们如果让特性定义的方法直接回传其自身的类型,会导致这个特性无法作为特性对象使用。
主程序的代码如下:
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
assert_eq!("", post.content());
post.request_review();
assert_eq!("", post.content());
post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
主程序一开始,使用 Post 结构体的 new 关联函数,创建出新的 Post 结构实体。此时这个 Post 结构实体的状态为 Draft,且文章内容为空字符串。当文章状态为 Draft 时,使用 Post 结构实体的 content 方法会永远回传空字符串,因为在替 Draft 结构体实作 State 特性时并未去覆写原先只会回传空字符串的 content 方法。接着,在文章状态为 Draft 时,调用 Post 结构实体的 request_review 方法,会让文章的状态改为 PendingReview,此时 Post 结构实体的 content 方法依然只会回传空字符串。再来,在文章状态为 PendingReview 时,调用 Post 结构实体的 approve 方法,会让文章的状态改为 Published,此时 Post 结构实体的 content 方法就会回传 content 字段的字符串参考了!
以上这样的程序实作方式,即为面向对象的「状态模式」(State Pattern)。程序虽然有很好的扩充性,但也因此多了好几个重复且不应该被使用到的代码,例如当文章状态为 Draft 时,approve 方法虽然没有什么用处,但它应该根本就不能存在才对,同理,content 方法也是一样。但如果我们跳脱出面向对象思考的模式,将程序改写成:
pub struct Post {
content: String,
}
pub struct DraftPost {
content: String,
}
impl Post {
pub fn new() -> DraftPost {
DraftPost { content: String::new() }
}
pub fn content(&self) -> &str {
&(self.content)
}
}
impl DraftPost {
pub fn add_text(&mut self, text: &str) {
self.content.push_str(text);
}
pub fn request_review(self) -> PendingReviewPost {
PendingReviewPost { content: self.content }
}
}
pub struct PendingReviewPost {
content: String,
}
impl PendingReviewPost {
pub fn approve(self) -> Post {
Post { content: self.content }
}
}
use blog::Post;
fn main() {
let mut post = Post::new();
post.add_text("I ate a salad for lunch today");
let post = post.request_review();
let post = post.approve();
assert_eq!("I ate a salad for lunch today", post.content());
}
一开始使用 Post 结构体的 new 关联函数,会实体化 DraftPost 结构体。这个 DraftPost 结构实体只提供 add_text 和 request_review 方法,使用 request_review 方法后,会创建出并回传新的 PendingReviewPost 结构实体。PendingReviewPost 结构实体只提供 approve 方法,使用 approve 方法后,会创建出并回传新的 Post 结构实体。Post 结构实体只提供 content 方法,会将 content 字段的字符串参考回传。
跳脱面向对象程序的设计模式的程序,显然要比原先使用面向对象设计模式的程序还要精简许多。但这只是一个不使用面向对象编程会比较好的案例,而不能代表所有案例不使用面向对象编程都会比较好。开发者需要自行判断,要用怎么样的方式来设计程序会比较好!
结论
在这个章节中,我们了解到如何使用 Rust 编程语言开发面向对象程序,也了解到面向对象编程并非永远都是最好的选择。因此 Rust 编程语言保留了让开发者选择要用哪种方式或是设计模式来实作程序的空间,让开发者可以更有效地透过自身的知识和经验,写出更好的程序。
下一个章节我们要来学习 Rust 编程语言提供的字符串格式化功能,也就是 println!、format! 等等宏的高级用法啦!
下一章:格式化文字。


