Rust 面向对象（千字长文）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在编程世界中，面向对象（Object-Oriented）是许多开发者熟悉的设计范式。无论是 Java、Python 还是 C++，面向对象思想都以类（Class）、继承（Inheritance）、多态（Polymorphism）等概念为核心，帮助开发者构建复杂系统的抽象模型。然而，Rust 这门系统级语言虽然支持面向对象的核心思想，却以独特的方式实现这些概念。本文将从编程初学者的角度出发，逐步解析 Rust 如何通过结构体（Struct）、方法（Method）、Trait 和组合（Composition）等机制，实现面向对象的设计模式，并通过实际案例展示其灵活性与安全性。

Rust 面向对象的核心思想：结构体与方法

在传统面向对象语言中，类是封装数据和行为的基本单位。而在 Rust 中，结构体（Struct）承担了类似的角色，它允许开发者定义自定义的数据类型，并通过方法（Method）为其附加行为。

结构体：数据容器的化身

结构体是 Rust 中定义复合数据类型的工具。例如，我们可以用结构体描述一个“Person”对象：

struct Person {  
    name: String,  
    age: u32,  
}  

在这个例子中，Person 结构体拥有两个字段：name（字符串类型）和 age（无符号 32 位整数）。通过结构体，我们可以将相关数据组织在一起，形成一个逻辑单元。

方法：为结构体赋予“行为”

方法是 Rust 中为结构体添加功能的核心手段。与传统类中的方法类似，Rust 的方法直接绑定到结构体上。例如，我们可以为 Person 结构体添加一个 greet 方法：

impl Person {  
    fn greet(&self) {  
        println!("Hello, my name is {} and I'm {} years old.", self.name, self.age);  
    }  
}  

这里的关键在于 impl 块（implementation block），它允许我们将方法与特定结构体关联。&self 参数表示该方法需要一个结构体的引用，从而避免数据所有权的转移。

比喻：结构体如同一个装满数据的盒子，而方法则是贴在盒子上的操作说明。

组合优于继承：Rust 的设计理念

与其他面向对象语言不同，Rust 并不支持传统的继承（Inheritance）机制。取而代之的是，Rust 强调“组合”（Composition），即通过将多个结构体或 Trait 组合在一起，构建复杂的数据类型。

组合的实践：构建“动物”系统

假设我们要设计一个简单的“动物”系统，包含 Dog 和 Cat 两种类型。在 Rust 中，可以通过结构体组合实现这一目标：

struct Animal {  
    name: String,  
    age: u32,  
}  

struct Dog {  
    animal: Animal,  
    breed: String,  
}  

impl Dog {  
    fn bark(&self) {  
        println!("{} the {} says: Woof!", self.animal.name, self.breed);  
    }  
}  

在这个例子中，Dog 结构体通过包含 Animal 结构体，复用了 name 和 age 字段。这种方法虽然与传统的继承不同，但通过组合实现了类似的效果，并且避免了继承带来的复杂性（如菱形继承问题）。

比喻：继承是“我是谁”的关系，而组合是“我拥有什么”的关系。

Trait：Rust 中的接口与多态

在 Rust 中，Trait（特征）扮演了类似接口（Interface）的角色，它定义了一组方法的签名，但不提供具体实现。通过 Trait，开发者可以实现多态（Polymorphism），即不同结构体共享同一行为。

Trait 的定义与实现

例如，我们可以定义一个 Speaker Trait，要求实现者能够执行 speak 方法：

trait Speaker {  
    fn speak(&self);  
}  

impl Speaker for Dog {  
    fn speak(&self) {  
        self.bark(); // 调用 Dog 自身的方法  
    }  
}  

struct Cat {  
    animal: Animal,  
    fur_color: String,  
}  

impl Speaker for Cat {  
    fn speak(&self) {  
        println!("{} the cat says: Meow!", self.animal.name);  
    }  
}  

通过上述代码，Dog 和 Cat 都实现了 Speaker Trait，因此可以被统一处理为 Speaker 类型。例如：

fn make_speak(speaker: &dyn Speaker) {  
    speaker.speak();  
}  

let dog = Dog {  
    animal: Animal { name: String::from("Buddy"), age: 3 },  
    breed: String::from("Golden Retriever"),  
};  

let cat = Cat {  
    animal: Animal { name: String::from("Whiskers"), age: 2 },  
    fur_color: String::from("Gray"),  
};  

make_speak(&dog); // 输出：Buddy the Golden Retriever says: Woof!  
make_speak(&cat); // 输出：Whiskers the cat says: Meow!  

比喻：Trait 是一张“技能证书”，而结构体通过实现 Trait，证明自己具备相应的技能。

高级特性：泛型与生命周期

Rust 的面向对象设计不仅止步于结构体和 Trait，还通过泛型（Generics）和生命周期（Lifetime）等特性，进一步增强代码的灵活性与安全性。

泛型：让代码更通用

泛型允许开发者编写适用于多种数据类型的代码。例如，我们可以定义一个 Printer 结构体，能够打印任意实现了 Display Trait 的类型：

struct Printer<T> {  
    content: T,  
}  

impl<T> Printer<T> {  
    fn print(&self) where T: std::fmt::Display {  
        println!("{}", self.content);  
    }  
}  

let number_printer = Printer { content: 42 };  
number_printer.print(); // 输出：42  

let string_printer = Printer { content: "Hello, Rust!" };  
string_printer.print(); // 输出：Hello, Rust!  

通过泛型，Printer 结构体无需为不同数据类型重复编写代码，而是通过约束（如 T: Display）确保类型安全。

生命周期：解决借用问题

当结构体包含引用时，Rust 的生命周期（Lifetime）机制确保引用的存活期不会超过所引用对象的生命周期。例如：

struct BorrowedData<'a> {  
    data: &'a str,  
}  

// 正确使用：引用的生命周期与结构体一致  
let text = "Hello";  
let borrowed = BorrowedData { data: text };  

如果尝试让结构体的生命周期超过其引用对象的生命周期，编译器将直接报错，避免了悬垂指针（Dangling Pointer）的风险。

实战案例：构建一个“图形”系统

通过上述知识点，我们可以构建一个更复杂的面向对象案例：一个支持多种图形（如矩形、圆形）的面积计算系统。

步骤 1：定义通用接口

首先，定义一个 Shape Trait，要求所有图形实现 area 方法：

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

步骤 2：实现具体结构体

为矩形和圆形定义结构体，并实现 Shape Trait：

struct Rectangle {  
    width: f64,  
    height: f64,  
}  

impl Shape for Rectangle {  
    fn area(&self) -> f64 {  
        self.width * self.height  
    }  
}  

struct Circle {  
    radius: f64,  
}  

impl Shape for Circle {  
    fn area(&self) -> f64 {  
        std::f64::consts::PI * self.radius.powi(2)  
    }  
}  

步骤 3：统一处理图形

通过 Trait 对象（Box<dyn Shape>）实现多态，计算任意图形的面积：

fn calculate_area(shape: &dyn Shape) -> f64 {  
    shape.area()  
}  

let rectangle = Rectangle { width: 5.0, height: 3.0 };  
let circle = Circle { radius: 2.0 };  

println!("Rectangle area: {}", calculate_area(&rectangle)); // 15.0  
println!("Circle area: {}", calculate_area(&circle)); // ~12.566  

比喻：Trait 是一张“入场券”，而具体结构体是持券入场的不同角色，共同参与同一场游戏。

结论

Rust 的面向对象设计虽然与传统语言不同，但通过结构体、方法、Trait 和组合等机制，同样能够实现数据抽象、封装和多态的核心思想。这种设计既保留了 Rust 的内存安全和性能优势，又为开发者提供了灵活的面向对象编程体验。

对于初学者而言，理解 Rust 的“面向对象”需要跳出“类与继承”的思维定式，转而拥抱结构体组合、Trait 接口和泛型等新概念。通过本文的案例和代码示例，希望读者能够掌握 Rust 面向对象的核心方法，并在实际项目中灵活运用。

记住：Rust 的面向对象不是“类的替代品”，而是一套重新设计的、更安全的面向对象哲学。