Rust 面向对象特性解析：对象、封装与继承
1. Rust 的对象概念
在《设计模式：可复用面向对象软件的基础》（Design Patterns: Elements of Reusable Object-Oriented Software）一书中，作者将对象定义为：
对象是数据和操作该数据的过程的封装体。
按照这个定义，Rust 通过 struct 和 enum 提供数据封装，并且可以使用 impl 块为其定义方法。因此，Rust 具备面向对象语言中的“对象”特性。
示例代码：
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
fn main() {
let rect = Rectangle { width: 30, height: 50 };
println!("Rectangle area: {}", rect.area());
}
在这个例子中，Rectangle 结构体包含 width 和 height 两个字段，并通过 impl 块定义了 area 方法。这与 OOP 语言中的对象概念类似。
2. 封装：隐藏实现细节
封装（Encapsulation）是 OOP 的核心原则之一，它确保对象的内部状态不能被外部直接访问，而是通过公开的方法进行操作。Rust 使用 pub 关键字控制可见性。
示例代码：
pub struct AveragedCollection {
list: Vec<i32>,
average: f64,
}
impl AveragedCollection {
pub fn new() -> Self {
Self { list: vec![], average: 0.0 }
}
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();
if result.is_some() {
self.update_average();
}
result
}
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 结构体中：
list和average字段是私有的，不能直接被外部访问。- 只能通过
add、remove和average方法来操作数据，确保average始终是最新的。
这种封装方式确保了对象的内部状态不会被外部代码直接修改，从而避免数据不一致的问题。
3. 继承：Rust 的替代方案
3.1 Rust 不支持传统继承
在传统的 OOP 语言（如 Java、C++）中，继承（Inheritance） 允许子类继承父类的字段和方法。然而，Rust 并不支持传统的继承，而是鼓励使用 特征（Traits） 和 组合（Composition） 进行代码复用。
Rust 选择不支持继承的原因：
- 减少代码耦合：继承往往导致复杂的类层次结构，使得代码难以维护。
- 提高灵活性：通过特征和组合，可以实现更灵活的代码复用方式。
3.2 用特征（Traits）实现行为复用
在 Rust 中，可以使用 特征（Traits） 作为继承的替代方案，为不同类型定义通用行为。
trait Summary {
fn summarize(&self) -> String;
}
struct NewsArticle {
title: String,
content: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}", self.title)
}
}
struct Tweet {
username: String,
content: String,
}
impl Summary for Tweet {
fn summarize(&self) -> String {
format!("@{}: {}", self.username, self.content)
}
}
fn main() {
let article = NewsArticle {
title: String::from("Rust 发布 1.70 版本"),
content: String::from("Rust 1.70 带来了很多新特性……"),
};
let tweet = Tweet {
username: String::from("rustlang"),
content: String::from("Rust 让并发变得更简单！"),
};
println!("Article: {}", article.summarize());
println!("Tweet: {}", tweet.summarize());
}
在这个例子中，Summary 特征提供了 summarize 方法，而 NewsArticle 和 Tweet 结构体分别实现了该特征。这种方式类似于 OOP 语言中的接口（Interface），允许不同的类型共享相同的行为。
3.3 组合（Composition）代替继承
除了特征，Rust 还鼓励使用组合（Composition） 代替继承，即通过将结构体嵌套来复用代码。
struct Engine {
horsepower: u32,
}
struct Car {
engine: Engine,
brand: String,
}
impl Car {
fn new(brand: &str, horsepower: u32) -> Self {
Self { engine: Engine { horsepower }, brand: brand.to_string() }
}
}
在这个例子中，Car 结构体包含 Engine 结构体，而不是继承它。这种方式避免了继承带来的复杂性，并提高了代码的灵活性。
4. Rust 的多态（Polymorphism）
Rust 通过泛型（Generics） 和 特征对象（Trait Objects） 来实现多态，而不是传统 OOP 语言中的类继承。
4.1 泛型
泛型允许我们编写可以适用于多种类型的代码。
fn print_item<T: Summary>(item: &T) {
println!("{}", item.summarize());
}
4.2 特征对象
特征对象允许在运行时进行多态调度：
fn notify(item: &dyn Summary) {
println!("Breaking news! {}", item.summarize());
}
&dyn Summary 允许我们传递任何实现 Summary 特征的类型。
5. 结论
Rust 采用了不同于传统 OOP 语言的方式来实现对象、封装和多态：
- 对象：使用
struct和impl。 - 封装：通过
pub控制可见性。 - 继承替代方案：使用 特征（Traits） 和 组合（Composition） 代替继承。
- 多态：使用 泛型 和 特征对象。
这些特性让 Rust 既能享受 OOP 的优点，又避免了传统 OOP 语言中的一些缺陷，使其成为现代系统编程的强大工具。