🎬 HoRain云小助手：个人主页

 🔥 个人专栏: 《Linux 系列教程》《c语言教程》

⛺️生活的理想，就是为了理想的生活!

---

⛳️ 推荐

前些天发现了一个超棒的服务器购买网站，性价比超高，大内存超划算！忍不住分享一下给大家。点击跳转到网站。

专栏介绍

专栏名称	专栏介绍
《C语言》	本专栏主要撰写C干货内容和编程技巧，让大家从底层了解C，把更多的知识由抽象到简单通俗易懂。
《网络协议》	本专栏主要是注重从底层来给大家一步步剖析网络协议的奥秘，一起解密网络协议在运行中协议的基本运行机制！
《docker容器精解篇》	全面深入解析 docker 容器，从基础到进阶，涵盖原理、操作、实践案例，助您精通 docker。
《linux系列》	本专栏主要撰写Linux干货内容，从基础到进阶，知识由抽象到简单通俗易懂，帮你从新手小白到扫地僧。
《python 系列》	本专栏着重撰写Python相关的干货内容与编程技巧，助力大家从底层去认识Python，将更多复杂的知识由抽象转化为简单易懂的内容。
《试题库》	本专栏主要是发布一些考试和练习题库（涵盖软考、HCIE、HRCE、CCNA等）

目录

⛳️ 推荐

专栏介绍

---

Rust 虽不是传统意义上的面向对象语言，但它通过结构体、特质（Trait）、泛型和组合等特性，提供了强大且安全的方式来实现面向对象编程（OOP）的核心思想：封装、继承和多态。下面这个表格汇总了 Rust 实现 OOP 核心概念的主要方式：

OOP 概念	Rust 实现方式	关键特性
​​封装​​	结构体 (struct)、模块 (mod)、可见性 (pub)	数据与行为结合，默认私有，通过 pub控制可见性
​​继承​​	特质 (trait)、组合	使用特质共享接口和行为，组合优于继承
​​多态​​	特质对象 (dyn Trait)、泛型 (Generics)	运行时多态（特质对象）、编译时多态（泛型）

🧱 ​​封装 (Encapsulation)​​

封装是将数据和行为捆绑在一起，并隐藏内部实现细节。Rust 通过结构体（struct）和模块（mod）来实现。

• ​​结构体封装数据​​：结构体可以将多个字段组合在一起。默认情况下，这些字段是私有的（仅在定义它的模块及子模块内可访问），你可以使用 pub关键字来指定公有字段和方法。

  pub struct BankAccount {
      balance: f64, // 私有字段
  }
  
  impl BankAccount {
      // 公有关联函数（类似静态方法）
      pub fn new() -> Self {
          BankAccount { balance: 0.0 }
      }
  
      // 公有实例方法
      pub fn deposit(&mut self, amount: f64) {
          self.balance += amount;
      }
  
      // 公有方法，提供对私有字段的受控访问
      pub fn get_balance(&self) -> f64 {
          self.balance
      }
  }

  上面的 BankAccount结构体，其 balance字段是私有的，外部代码无法直接修改。只能通过公有的 deposit和 get_balance方法来操作和访问余额，这就实现了封装。

• ​​模块增强封装​​：模块可以帮助你组织代码并控制可见性。你可以将相关的结构体、特质、函数等放在一个模块中，并使用 pub决定哪些项可以在模块外部使用。

⚙️ ​​继承 (Inheritance) 与多态 (Polymorphism)​​

Rust ​​没有​​传统意义上的类继承机制。它使用​​特质（Trait）​​ 和​​组合（Composition）​​ 来共享代码和行为，这通常能提供更好的灵活性并避免继承的某些弊端。

• ​​特质定义共享行为​​：特质定义了方法签名，不同类型可以实现同一个特质。这类似于其他语言中的接口。

  // 定义特质
  trait Shape {
      fn area(&self) -> f64;
  }
  
  // 为不同结构体实现特质
  struct Circle {
      radius: f64,
  }
  
  impl Shape for Circle {
      fn area(&self) -> f64 {
          std::f64::consts::PI * self.radius * self.radius
      }
  }
  
  struct Rectangle {
      width: f64,
      height: f64,
  }
  
  impl Shape for Rectangle {
      fn area(&self) -> f64 {
          self.width * self.height
      }
  }

• ​​多态的实现​​：多态允许我们使用统一的接口处理不同的类型。

  • ​​通过特质对象实现运行时多态​​：使用 dyn Trait可以实现运行时多态。

    // 函数接受任何实现 Shape 特质的类型的特质对象
    fn print_area(shape: &dyn Shape) {
        println!("面积是: {}", shape.area());
    }
    
    fn main() {
        let circle = Circle { radius: 5.0 };
        let rectangle = Rectangle { width: 3.0, height: 4.0 };
    
        print_area(&circle);    // 输出：面积是: 78.53975
        print_area(&rectangle); // 输出：面积是: 12
    }

  • ​​通过泛型实现编译时多态​​：使用泛型和特质约束（Trait Bound）可以在编译时实现多态，性能更高。

    // 泛型函数，T 必须实现 Shape 特质
    fn print_area<T: Shape>(shape: &T) {
        println!("面积是: {}", shape.area());
    }

• ​​组合优于继承​​：Rust 鼓励使用组合来构建复杂功能，即将一个类型的实例作为另一个类型的字段。

  struct Engine {
      horsepower: u32,
  }
  
  impl Engine {
      fn start(&self) {
          println!("引擎启动！马力: {}", self.horsepower);
      }
  }
  
  struct Car {
      engine: Engine, // 组合
      brand: String,
  }
  
  impl Car {
      fn new(horsepower: u32, brand: &str) -> Self {
          Car {
              engine: Engine { horsepower },
              brand: String::from(brand),
          }
      }
  
      fn drive(&self) {
          self.engine.start();
          println!("{}汽车开始行驶", self.brand);
      }
  }

🔧 ​​常用特质与自动派生​​

Rust 标准库提供了许多有用的特质，你可以使用 #[derive]属性自动为你的类型派生这些特质的默认实现，例如：

• Debug: 用于使用 {:?}格式化打印调试信息。

• Clone/ Copy: 用于值的复制。

• PartialEq/ Eq: 用于相等比较。

• PartialOrd/ Ord: 用于排序比较。

#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

💡 ​​总结与建议​​

Rust 通过结构体、特质、泛型和组合，以一种独特且高效的方式支持了面向对象编程的核心思想。虽然它没有传统的类继承，但这种设计往往能引导你写出​​更灵活、更解耦、更安全​​的代码，并充分利用 Rust 的​​所有权系统​​和​​零成本抽象​​带来的性能和安全性优势。

要掌握 Rust 的面向对象编程，建议多练习：

• 为你自定义的结构体实现方法。

• 定义特质并为不同类型实现它们。

• 编写使用特质对象或泛型的函数来实现多态。

• 思考如何使用组合来构建复杂的对象。

❤️❤️❤️本人水平有限，如有纰漏，欢迎各位大佬评论批评指正！😄😄😄

💘💘💘如果觉得这篇文对你有帮助的话，也请给个点赞、收藏下吧，非常感谢!👍 👍 👍

🔥🔥🔥Stay Hungry Stay Foolish 道阻且长,行则将至,让我们一起加油吧！🌙🌙🌙