目录
什么是 Rust 面向对象
Rust 面向对象是指在 Rust 中实现类似传统面向对象编程 (OOP) 的概念，如封装、继承和多态。尽管 Rust 不是典型的 OOP 语言，它通过结构体、特性 (traits) 和所有权系统提供了灵活的替代方案。
为什么要使用面向对象
- 代码组织：将数据和行为绑定，提高可读性。
- 复用性：通过特性共享行为。
- 抽象性：隐藏实现细节，提供通用接口。
- 模块化：便于维护和扩展。
Rust 中的面向对象特性
- 结构体 (Struct)：定义数据。
- 特性 (Traits)：定义行为，类似接口。
- 实现 (Impl)：为结构体绑定方法。
- 所有权：管理数据生命周期。
封装与数据隐藏
- 封装：将数据和方法组合在结构体中。
- 数据隐藏：
- 默认字段私有。
- 使用
pub控制可见性。
struct Counter {
count: i32, // 私有字段
}
impl Counter {
pub fn new() -> Counter { // 公开构造函数
Counter { count: 0 }
}
pub fn increment(&mut self) { // 公开方法
self.count += 1;
}
}
继承与多态的替代
- 继承：
- Rust 不支持传统继承。
- 替代：特性组合或结构体嵌套。
- 多态：
- 使用特性对象 (
dyn Trait) 或泛型。 dyn Trait：动态分发。- 泛型：静态分发。
trait Shape {
fn area(&self) -> f64;
}
代码示例
封装示例
struct User {
name: String, // 私有
age: u32, // 私有
}
impl User {
pub fn new(name: &str, age: u32) -> User {
User { name: String::from(name), age }
}
pub fn get_name(&self) -> &str {
&self.name
}
}
fn main() {
let user = User::new("Alice", 30);
println!("Name: {}", user.get_name());
}
运行结果：
Name: Alice
特性与多态
trait Animal {
fn speak(&self) -> String;
}
struct Dog;
struct Cat;
impl Animal for Dog {
fn speak(&self) -> String {
String::from("Woof!")
}
}
impl Animal for Cat {
fn speak(&self) -> String {
String::from("Meow!")
}
}
fn make_sound(animal: &dyn Animal) {
println!("{}", animal.speak());
}
fn main() {
let dog = Dog;
let cat = Cat;
make_sound(&dog);
make_sound(&cat);
}
运行结果：
Woof!
Meow!
泛型多态
trait Printable {
fn print(&self);
}
struct Item<T> {
value: T,
}
impl<T: Printable> Item<T> {
fn display(&self) {
self.value.print();
}
}
struct Number(i32);
impl Printable for Number {
fn print(&self) {
println!("Number: {}", self.0);
}
}
fn main() {
let item = Item { value: Number(42) };
item.display();
}
运行结果：
Number: 42
参考资料与出站链接
- 官方文档：
- 学习资源：
- 社区支持：
发表回复