深入解析 Rust 的面向对象编程：特性、实现与设计模式

寻月隐君
发布于 10小时前
阅读 58

深入解析Rust的面向对象编程：特性、实现与设计模式Rust作为一门兼顾性能与安全的现代编程语言，其独特的编程范式引发了广泛讨论。它是否是一门面向对象语言？如何在Rust中实现面向对象的特性？本文将深入剖析Rust的面向对象编程特性，探讨其封装、trait对象、动态派发以及状态模式

# 深入解析 Rust 的面向对象编程：特性、实现与设计模式
Rust 作为一门兼顾性能与安全的现代编程语言，其独特的编程范式引发了广泛讨论。它是否是一门面向对象语言？如何在 Rust 中实现面向对象的特性？本文将深入剖析 Rust 的面向对象编程特性，探讨其封装、trait 对象、动态派发以及状态模式等核心概念，并通过代码示例展示 Rust 如何以独特的方式实现面向对象设计模式，为开发者提供灵活而高效的编程体验。

本文从面向对象编程的基本特性出发，分析了 Rust 是否符合面向对象语言的定义，重点介绍了 Rust 的封装机制、trait 对象的使用以及动态派发的实现方式。通过 GUI 工具和博客发布工作流的案例，展示了 Rust 如何通过 trait 和类型系统实现面向对象的设计模式，例如状态模式。同时，文章探讨了 Rust 相较于传统面向对象语言的独特之处，如避免继承、利用所有权机制实现状态管理，并分析了状态模式的优缺点及替代方案，旨在帮助开发者更好地理解和应用 Rust 的面向对象编程思想。

## 一、面向对象语言的特性

### Rust是面向对象编程语言吗？

- Rust 受到多种编程范式的影响，包括面向对象
- 面向对象通常包含以下特性：命名对象、封装、继承

### 对象包含数据和行为

- “设计模式四人帮”在《设计模型》中给面向对象的定义：
  - 面向对象的程序由对象组成
  - 对象包装了数据和操作这些数据的过程，这些过程通常被称作方法或操作
- 基于此定义：Rust是面向对象的
  - struct、enum 包含数据
  - impl 块为之提供了方法
  - 但带有方法的 struct、enum 并没有被称为对象

### 封装

- 封装：调用对象外部的代码无法直接访问对象内部的实现细节，唯一可以与对象进行交互的方法就是通过它公开的 API
- Rust：pub 关键字

```rust
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;
  }
}
```

### 继承

- 继承：使对象可以沿用另外一个对象的数据和行为，且无需重复定义相关代码
- Rust：没有继承
- 使用继承的原因：
  - 代码复用
    - Rust：默认 trait 方法来进行代码共享
  - 多态
    - Rust：泛型和 trait 约束（限定参数化多态 bounded parametric）
- 很多新语言都不使用继承作为内置的程序设计方案了。

## 二、使用 trait 对象来存储不同类型的值

### 有这样一个需求

- 创建一个 GUI 工具：
  - 它会遍历某个元素的列表，依次调用元素的 draw 方法进行绘制
  - 例如：Button、TextField 等元素
- 在面向对象语言里：
  - 定义一个 Component 父类，里面定义了 draw 方法
  - 定义 Button、TextField 等类，继承与 Component 类

### 为共有行为定义一个 trait

- Rust 避免将 struct 或 enum 称为对象，因为他们与 impl 块是分开的
- trait 对象有些类似于其它语言中的对象：
  - 它们某种程度上组合了数据与行为
- trait 对象与传统对象不同的地方：
  - 无法为 trait 对象添加数据
- trait 对象被专门用于抽象某些共有行为，它没其它语言中的对象那么通用

### Trait  动态 lib.rs 文件

```rust
pub trait Draw {
  fn draw(&self);
}

pub struct Screen {
  pub components: Vec<Boc<dyn Draw>>,
}

impl Screen {
  pub fn run(&self) {
    for component in self.components.iter() {
      component.draw();
    }
  }
}

pub struct Button {
  pub width: u32,
  pub height: u32,
  pub label: String,
}

impl Draw for Button {
  fn draw(&self) {
    // 绘制一个按钮
  }
}
```

### 泛型的实现 一次只能实现一个类型

```rust
pub struct Screen<T: Draw> {
  pub components: Vec<T>,
}

impl<T> Screen<T>
where
 T: Draw,
{
  pub fn run(&self) {
    for component in self.components.iter() {
      component.draw()
    }
  }
}
```

### main.rs 文件

```rust
use oo::Draw;
use oo::{Button, Screen};

struct SelectBox {
  width: u32,
  height: u32,
  options: Vec<String>,
}

impl Draw for SelectBox {
  fn draw(&self) {
    // 绘制一个选择框
  }
}

fn main() {
  let screen = Screen {
    components: vec![
      Box::new(SelectBox {
        width: 75,
        height: 10,
        options: vec![
          String::from("Yes"),
          String::from("Maybe"),
          String::from("No"),
        ],
      }),
      Box::new(Button {
        width: 50,
        height: 10,
        label: String::from("OK"),
      }),
    ],
  };
  
  screen.run();
}
```

### Trait 对象执行的是动态派发

- 将 trait 约束作用于泛型时，Rust编译器会执行单态化：
  - 编译器会为我们用来替换泛型参数的每一个具体类型生成对应函数和方法的非泛型实现。
- 通过单态化生成的代码会执行静态派发（static dispatch），在编译过程中确定调用的具体方法
- 动态派发（dynamic dispatch）：
  - 无法在编译过程中确定你调用的究竟是哪一种方法
  - 编译器会产生额外的代码以便在运行时找出希望调用的方法
- 使用 trait 对象，会执行动态派发：
  - 产生运行时开销
  - 阻止编译器内联方法代码，使得部分优化操作无法进行

### Trait 对象必须保证对象安全

- 只能把满足对象安全（object-safe）的 trait 转化为 trait 对象
- Rust采用一系列规则来判定某个对象是否安全，只需记住两条：
  - 方法的返回类型不是 Self
  - 方法中不包含任何泛型类型参数

### lib.rs 文件

```rust
pub trait Draw {
  fn draw(&self);
}

pub trait Clone {
  fn clone(&self) -> Self;
}

pub struct Screen {
  pub components: Vec<Box<dyn Clone>>, // 报错
}
```

## 三、实现面向对象的设计模式

### 状态模式

- 状态模式（state pattern）是一种面向对象设计模式：
  - 一个值拥有的内部状态由数个状态对象（state object）表达而成，而值的行为则随着内部状态的改变而改变
- 使用状态模式意味着：
  - 业务需求变化时，不需要修改持有状态的值的代码，或者使用这个值的代码
  - 只需要更新状态对象内部的代码，以便改变其规则，或者增加一些新的状态对象

### 例子：发布博客的工作流程 main.rs

```rust
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());
}
```

### lib.rs 文件

```rust
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 {
    ""
  }
  
  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>;
}

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 PendingRevew {
  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
  }
}
```

### 修改之后：

```rust
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 PendingRevew {
  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
  }
}
```

### 状态模式的取舍权衡

- 缺点：
  - 某些状态之间是相互耦合的
  - 需要重复实现一些逻辑代码

### 将状态和行为编码为类型

- 将状态编码为不同的类型：
  - Rust 类型检查系统会通过编译时错误来阻止用户使用无效的状态

### lib.rs 代码：

```rust
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,
    }
  }
}
```

### main.rs 代码：

```rust
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());
}
```

### 总结

- Rust 不仅能够实现面向对象的设计模式，还可以支持更多的模式
- 例如：将状态和行为编码为类型
- 面向对象的经典模式并不总是 Rust 编程实践中的最佳选择，因为 Rust具有所有权等其它面向对象语言没有的特性！
## 总结
Rust 虽然不完全是传统意义上的面向对象语言，但通过 struct、trait 和 impl 块等机制，它能够灵活实现封装、多态等面向对象特性，同时避免了继承的复杂性。trait 对象和动态派发为处理多类型值提供了强大支持，而状态模式等设计模式的实现则展示了 Rust 类型系统的严谨性与灵活性。相比传统面向对象语言，Rust 结合所有权和类型检查的特性，为开发者提供了更安全、高效的编程方式。无论是实现经典的面向对象设计模式，还是探索更符合 Rust 哲学的编码方式，Rust 都为开发者提供了广阔的可能性。

## 参考
- https://course.rs/about-book.html
- https://github.com/rust-lang
- https://www.rust-lang.org/
- https://github.com/rust-boom/rust-boom
- https://rust-lang-nursery.github.io/rust-cookbook/intro.html

深入解析 Rust 的面向对象编程：特性、实现与设计模式

Rust 作为一门兼顾性能与安全的现代编程语言，其独特的编程范式引发了广泛讨论。它是否是一门面向对象语言？如何在 Rust 中实现面向对象的特性？本文将深入剖析 Rust 的面向对象编程特性，探讨其封装、trait 对象、动态派发以及状态模式等核心概念，并通过代码示例展示 Rust 如何以独特的方式实现面向对象设计模式，为开发者提供灵活而高效的编程体验。

一、面向对象语言的特性

Rust是面向对象编程语言吗？

Rust 受到多种编程范式的影响，包括面向对象
面向对象通常包含以下特性：命名对象、封装、继承

对象包含数据和行为

“设计模式四人帮”在《设计模型》中给面向对象的定义：
- 面向对象的程序由对象组成
- 对象包装了数据和操作这些数据的过程，这些过程通常被称作方法或操作
基于此定义：Rust是面向对象的
- struct、enum 包含数据
- impl 块为之提供了方法
- 但带有方法的 struct、enum 并没有被称为对象

封装

封装：调用对象外部的代码无法直接访问对象内部的实现细节，唯一可以与对象进行交互的方法就是通过它公开的 API
Rust：pub 关键字

pub struct AveragedCollection {
  list: Vec&lt;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&lt;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;
  }
}

继承

继承：使对象可以沿用另外一个对象的数据和行为，且无需重复定义相关代码
Rust：没有继承
使用继承的原因：
- 代码复用
- Rust：默认 trait 方法来进行代码共享
- 多态
- Rust：泛型和 trait 约束（限定参数化多态 bounded parametric）
很多新语言都不使用继承作为内置的程序设计方案了。

二、使用 trait 对象来存储不同类型的值

有这样一个需求

创建一个 GUI 工具：
- 它会遍历某个元素的列表，依次调用元素的 draw 方法进行绘制
- 例如：Button、TextField 等元素
在面向对象语言里：
- 定义一个 Component 父类，里面定义了 draw 方法
- 定义 Button、TextField 等类，继承与 Component 类

为共有行为定义一个 trait

Rust 避免将 struct 或 enum 称为对象，因为他们与 impl 块是分开的
trait 对象有些类似于其它语言中的对象：
- 它们某种程度上组合了数据与行为
trait 对象与传统对象不同的地方：
- 无法为 trait 对象添加数据
trait 对象被专门用于抽象某些共有行为，它没其它语言中的对象那么通用

Trait 动态 lib.rs 文件

pub trait Draw {
  fn draw(&self);
}

pub struct Screen {
  pub components: Vec&lt;Boc&lt;dyn Draw>>,
}

impl Screen {
  pub fn run(&self) {
    for component in self.components.iter() {
      component.draw();
    }
  }
}

pub struct Button {
  pub width: u32,
  pub height: u32,
  pub label: String,
}

impl Draw for Button {
  fn draw(&self) {
    // 绘制一个按钮
  }
}

泛型的实现一次只能实现一个类型

pub struct Screen&lt;T: Draw> {
  pub components: Vec&lt;T>,
}

impl&lt;T> Screen&lt;T>
where
 T: Draw,
{
  pub fn run(&self) {
    for component in self.components.iter() {
      component.draw()
    }
  }
}

main.rs 文件

use oo::Draw;
use oo::{Button, Screen};

struct SelectBox {
  width: u32,
  height: u32,
  options: Vec&lt;String>,
}

impl Draw for SelectBox {
  fn draw(&self) {
    // 绘制一个选择框
  }
}

fn main() {
  let screen = Screen {
    components: vec![
      Box::new(SelectBox {
        width: 75,
        height: 10,
        options: vec![
          String::from("Yes"),
          String::from("Maybe"),
          String::from("No"),
        ],
      }),
      Box::new(Button {
        width: 50,
        height: 10,
        label: String::from("OK"),
      }),
    ],
  };

  screen.run();
}

Trait 对象执行的是动态派发

将 trait 约束作用于泛型时，Rust编译器会执行单态化：
- 编译器会为我们用来替换泛型参数的每一个具体类型生成对应函数和方法的非泛型实现。
通过单态化生成的代码会执行静态派发（static dispatch），在编译过程中确定调用的具体方法
动态派发（dynamic dispatch）：
- 无法在编译过程中确定你调用的究竟是哪一种方法
- 编译器会产生额外的代码以便在运行时找出希望调用的方法
使用 trait 对象，会执行动态派发：
- 产生运行时开销
- 阻止编译器内联方法代码，使得部分优化操作无法进行

Trait 对象必须保证对象安全

只能把满足对象安全（object-safe）的 trait 转化为 trait 对象
Rust采用一系列规则来判定某个对象是否安全，只需记住两条：
- 方法的返回类型不是 Self
- 方法中不包含任何泛型类型参数

lib.rs 文件

pub trait Draw {
  fn draw(&self);
}

pub trait Clone {
  fn clone(&self) -> Self;
}

pub struct Screen {
  pub components: Vec&lt;Box&lt;dyn Clone>>, // 报错
}

三、实现面向对象的设计模式

状态模式

状态模式（state pattern）是一种面向对象设计模式：
- 一个值拥有的内部状态由数个状态对象（state object）表达而成，而值的行为则随着内部状态的改变而改变
使用状态模式意味着：
- 业务需求变化时，不需要修改持有状态的值的代码，或者使用这个值的代码
- 只需要更新状态对象内部的代码，以便改变其规则，或者增加一些新的状态对象

例子：发布博客的工作流程 main.rs

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());
}

lib.rs 文件

pub struct Post {
  state: Option&lt;Box&lt;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 {
    ""
  }

  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&lt;Self>) -> Box&lt;dyn State>;
  fn approve(self: Box&lt;Self>) -> Box&lt;dyn State>;
}

struct Draft {}

impl State for Draft {
  fn request_review(self: Box&lt;Self>) -> Box&lt;dyn State> {
    Box::new(PendingReview {})
  }

  fn approve(self: Box&lt;Self>) -> Box&lt;dyn State> {
    self
  }
}

struct PendingReview {}

impl State for PendingRevew {
  fn request_review(self: Box&lt;Self>) -> Box&lt;dyn State> {
    self
  }

  fn approve(self: Box&lt;Self>) -> Box&lt;dyn State> {
    Box::new(Published {})
  }
}

struct Published {}

impl State for Published {
  fn request_review(self: Box&lt;Self>) -> Box&lt;dyn State> {
    self
  }

  fn approve(self: Box&lt;Self>) -> Box&lt;dyn State> {
    self
  }
}

修改之后：

pub struct Post {
  state: Option&lt;Box&lt;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&lt;Self>) -> Box&lt;dyn State>;
  fn approve(self: Box&lt;Self>) -> Box&lt;dyn State>;
  fn content&lt;'a>(&self, post: &'a Post) -> &'a str {
    ""
  }
}

struct Draft {}

impl State for Draft {
  fn request_review(self: Box&lt;Self>) -> Box&lt;dyn State> {
    Box::new(PendingReview {})
  }

  fn approve(self: Box&lt;Self>) -> Box&lt;dyn State> {
    self
  }
}

struct PendingReview {}

impl State for PendingRevew {
  fn request_review(self: Box&lt;Self>) -> Box&lt;dyn State> {
    self
  }

  fn approve(self: Box&lt;Self>) -> Box&lt;dyn State> {
    Box::new(Published {})
  }
}

struct Published {}

impl State for Published {
  fn request_review(self: Box&lt;Self>) -> Box&lt;dyn State> {
    self
  }

  fn approve(self: Box&lt;Self>) -> Box&lt;dyn State> {
    self
  }

  fn content&lt;'a>(&self, post: &'a Post) -> &'a str {
    &post.content
  }
}

状态模式的取舍权衡

缺点：
- 某些状态之间是相互耦合的
- 需要重复实现一些逻辑代码

将状态和行为编码为类型

将状态编码为不同的类型：
- Rust 类型检查系统会通过编译时错误来阻止用户使用无效的状态

lib.rs 代码：

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,
    }
  }
}

main.rs 代码：

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());
}

总结

Rust 不仅能够实现面向对象的设计模式，还可以支持更多的模式
例如：将状态和行为编码为类型
面向对象的经典模式并不总是 Rust 编程实践中的最佳选择，因为 Rust具有所有权等其它面向对象语言没有的特性！
总结

Rust 虽然不完全是传统意义上的面向对象语言，但通过 struct、trait 和 impl 块等机制，它能够灵活实现封装、多态等面向对象特性，同时避免了继承的复杂性。trait 对象和动态派发为处理多类型值提供了强大支持，而状态模式等设计模式的实现则展示了 Rust 类型系统的严谨性与灵活性。相比传统面向对象语言，Rust 结合所有权和类型检查的特性，为开发者提供了更安全、高效的编程方式。无论是实现经典的面向对象设计模式，还是探索更符合 Rust 哲学的编码方式，Rust 都为开发者提供了广阔的可能性。

参考

原创
学分: 0
分类: Rust
标签: Rust

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

深入解析 Rust 的面向对象编程：特性、实现与设计模式

深入解析 Rust 的面向对象编程：特性、实现与设计模式

一、面向对象语言的特性

Rust是面向对象编程语言吗？

对象包含数据和行为

封装

继承

二、使用 trait 对象来存储不同类型的值

有这样一个需求

为共有行为定义一个 trait

Trait 动态 lib.rs 文件

泛型的实现一次只能实现一个类型

main.rs 文件

Trait 对象执行的是动态派发

Trait 对象必须保证对象安全

lib.rs 文件

三、实现面向对象的设计模式

状态模式

例子：发布博客的工作流程 main.rs

lib.rs 文件

修改之后：

状态模式的取舍权衡

将状态和行为编码为类型

lib.rs 代码：

main.rs 代码：

总结

总结

参考

0 条评论

专栏: Rust

文章目录

深入解析 Rust 的面向对象编程：特性、实现与设计模式

深入解析 Rust 的面向对象编程：特性、实现与设计模式

一、面向对象语言的特性

Rust是面向对象编程语言吗？

对象包含数据和行为

封装

继承

二、使用 trait 对象来存储不同类型的值

有这样一个需求

为共有行为定义一个 trait

Trait 动态 lib.rs 文件

泛型的实现 一次只能实现一个类型

main.rs 文件

Trait 对象执行的是动态派发

Trait 对象必须保证对象安全

lib.rs 文件

三、实现面向对象的设计模式

状态模式

例子：发布博客的工作流程 main.rs

lib.rs 文件

修改之后：

状态模式的取舍权衡

将状态和行为编码为类型

lib.rs 代码：

main.rs 代码：

总结

总结

参考

0 条评论

专栏: Rust

文章目录

泛型的实现一次只能实现一个类型