4.2 从 OOP 到 Rust on 编程那些事儿

4.2.1 继承

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/inheritance.html

4.2.1 继承

// 基类
class Vehicle {
public:
 void accelerate() { }
 void brake() { }
};

// 继承类
class Car : public Vehicle {
public:
 void honk() { }
};

int main() {
 Car myCar; // 创建 Car 对象
 myCar.accelerate(); // 继承的方法
 myCar.honk(); // Car 自己的方法
 myCar.brake(); // 继承的方法
 return 0;
}

这应是对学员在其它语言中「继承是什么」的简短提醒。

4.2.2 Rust 为何没有继承？

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/why-no-inheritance.html

4.2.2 Rust 为何没有继承？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub struct Id {
 pub id: u32
}

impl Id {
 // 方法
}

// 🔨❌，Rust 没有继承！
pub struct Data: Id {
 // 继承来的 "id" 字段
 pub name: String,
}

impl Data {
 // 方法，但也包含 Id 的方法，或者可能是对这些方法的覆盖。
}

// ✅
pub struct Data {
 pub id: Id,
 pub name: String,
}

impl Data {
 // Data 上所有非来自 trait 的方法。
}

impl SomeTrait for Data {
 // 在单独的 impl 块中为 trait 写实现。
}

继承带来若干缺点。

4.2.3 从 Rust 视角看继承

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/switch-perspective.html

4.2.3 从 Rust 视角看继承

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// 数据
pub struct Data {
 id: usize,
 name: String,
}

// 具体行为
impl Data {
 fn new(id: usize, name: impl Into<String>) -> Self {
 Self { id, name: name.into() }
 }
}

// 抽象行为
trait Named {
 fn name(&self) -> &str;
}

// 实例化的行为
impl Named for Data {
 fn name(&self) -> &str {
 &self.name
 }
}

从 Rust 的视角——一个从未有过继承的世界——引入继承会像是在类型与 trait 之间搅浑水。

4.2.4 Rust 中的「继承」与父 Trait

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/supertraits.html

4.2.4 Rust 中的「继承」与父 Trait

1
2
3
4
5


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub trait SuperTrait {}

pub trait Trait: SuperTrait {}

在 Rust 中，trait 可以依赖其它 trait。我们已经熟悉 trait 可以有父 trait（supertrait）。

4.2.5 组合优于继承

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/composition.html

4.2.5 组合优于继承

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub struct Uuid([u8; 16]);

pub struct Address {
 street: String,
 city_or_province: String,
 code: String,
 country: String,
}

pub struct User {
 id: Uuid,
 address: Address,
}

我们不用 mixin 或继承，而是通过创建不同类型的字段来组合类型。

4.2.6 Trait 对象与动态分发

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/dynamic-dispatch/dyn-trait.html

4.2.6 Trait 对象与动态分发

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub trait Trait {}

impl Trait for i32 {}
impl Trait for String {}

fn main() {
 let int: &dyn Trait = &42i32;
 let string: &dyn Trait = &String::from("Hello dyn!");;
}

动态分发是面向对象编程中的工具，常用于更关心类型行为而非类型本身是什么的场景。

4.2.7 Dyn 兼容性

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/dynamic-dispatch/dyn-compatible.html

4.2.7 Dyn 兼容性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
pub trait Trait {
 // dyn 兼容
 fn takes_self(&self);

 // dyn 兼容，但在 dyn 时不能使用此方法
 fn takes_self_and_param<T>(&self, input: &T);

 // 不再 dyn 兼容
 const ASSOC_CONST: i32;

 // 不再 dyn 兼容
 fn clone(&self) -> Self;
}

并非所有 trait 都能作为 trait 对象来调用。能这样调用的 trait 称为 dyn 兼容（dyn compatible）的 trait。

4.2.8 泛型 vs Trait 对象

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/dynamic-dispatch/dyn-vs-generics.html

4.2.8 泛型 vs Trait 对象

我们有两种编写多态函数的方式，它们如何比较？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
fn print_display<T: std::fmt::Display>(t: &T) {
 println!("{}", t);
}

fn print_display_dyn(t: &dyn std::fmt::Display) {
 println!("{}", t);
}

fn main() {
 let int = 42i32;
 // 单态化为针对 i32 输入的唯一函数。
 print_display(&int);
 // 每种
 print_display_dyn(&int);
}

我们可以用泛型或 trait 对象编写多态函数。

4.2.9 Trait 对象的局限

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/dynamic-dispatch/limits.html

4.2.9 Trait 对象的局限

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::any::Any;

pub trait Trait: Any {}

impl Trait for i32 {}

fn main() {
 dbg!(size_of::<i32>()); // 4 字节，拥有的值
 dbg!(size_of::<&i32>()); // 8 字节，引用
 dbg!(size_of::<&dyn Trait>()); // 16 字节，胖指针
}

Trait 对象是一种有限的解题方式。

4.2.10 异构集合

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/dynamic-dispatch/heterogeneous.html

4.2.10 异构集合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::fmt::Display;

pub struct Lambda;

impl Display for Lambda {
 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 write!(f, "λ")
 }
}

fn main() {
 let heterogeneous: Vec<Box<dyn Display>> = vec![
 Box::new(42u32),
 Box::new(String::from("Woah")),
 Box::new(Lambda),
 ];
 for item in heterogeneous {
 // 我们知道 "item" 实现了 Display，但别的一无所知！
 println!("Display output: {}", item);
 }
}

dyn Trait 作为动态分发工具，让我们能在集合中存放异构数据。

4.2.11 `Any` Trait

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/dynamic-dispatch/any-trait.html

4.2.11 `Any` Trait

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::any::Any;

#[derive(Debug)]
pub struct ThisImplementsAny;

fn take_any<T: Any>(t: &T) {}

fn main() {
 let is_an_any = ThisImplementsAny;
 take_any(&is_an_any);

 let dyn_any: &dyn Any = &is_an_any;
 dbg!(dyn_any.type_id());
 dbg!(dyn_any.is::<ThisImplementsAny>());
 let is_downcast: Option<&ThisImplementsAny> = dyn_any.downcast_ref();
 dbg!(is_downcast);
}

Any trait 让我们能把 dyn 值向下转型回具体值。

4.2.12 陷阱：过早伸手拿 `dyn Trait`

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/dynamic-dispatch/pitfalls.html

4.2.12 陷阱：过早伸手拿 `dyn Trait`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::any::Any;

pub trait AddDyn: Any {
 fn add_dyn(&self, rhs: &dyn AddDyn) -> Box<dyn AddDyn>;
}

impl AddDyn for i32 {
 fn add_dyn(&self, rhs: &dyn AddDyn) -> Box<dyn AddDyn> {
 if let Some(downcast) = (rhs as &dyn Any).downcast_ref::<Self>() {
 Box::new(self + downcast)
 } else {
 Box::new(*self)
 }
 }
}

fn main() {
 let i: &dyn AddDyn = &42;
 let j: &dyn AddDyn = &64;
 let k: Box<dyn AddDyn> = i.add_dyn(j);
 dbg!((k.as_ref() as &dyn Any).is::<i32>());
 dbg!((k.as_ref() as &dyn Any).downcast_ref::<i32>());
}

有 OOP 背景时，尽早伸手拿这个动态分发工具是可以理解的。

4.2.13 密封 Trait

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/sealed-traits.html

4.2.13 密封 Trait

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// crate 可以访问 "sealed" 模块及其 trait，但依赖它的项目不能。
mod sealed {
 pub trait Sealed {}
 impl Sealed for String {}
 impl Sealed for Vec<u8> {}
 //...
}

pub trait APITrait: sealed::Sealed {
 /* methods */
}
impl APITrait for String {}
impl APITrait for Vec<u8> {}

动机：我们希望在 crate 内使用由 trait 驱动的代码，但不希望依赖该 crate 的项目能够实现某个 trait。

为什么？

4.2.14 用枚举密封

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/sealing-with-enums.html

4.2.14 用枚举密封

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
use std::collections::BTreeMap;
pub enum GetSource {
 WebUrl(String),
 BytesMap(BTreeMap<String, Vec<u8>>),
}

impl GetSource {
 fn get(&self, url: &str) -> Option<&Vec<u8>> {
 match self {
 Self::WebUrl(source) => unimplemented!(),
 Self::BytesMap(map) => map.get(url),
 }
 }
}

动机：API 围绕一份有效类型列表设计，不期望 API 用户扩展它。

4.2.15 可被用户扩展的多态 Trait

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/sticking-with-traits.html

4.2.15 可被用户扩展的多态 Trait

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// Crate A

pub trait Trait {
 fn use_trait(&self) {}
}

// Crate B，依赖 A

pub struct Data(u8);

impl Trait for Data {}

fn main() {
 let data = Data(7u8);
 data.use_trait();
}

普通 trait 我们已经讲过很多；与枚举和密封 trait 相比，它们允许用户通过实现 API 所要求的行为来扩展 API。

这种可扩展性在许多领域都很强大，从序列化到硬件的抽象表示，再到类型安全的线性代数。

4.2.16 解题：拆解问题

Tue, 11 Aug 2026 11:30:00 +0800

译文 · 基于 Comprehensive Rust

原文链接: https://google.github.io/comprehensive-rust/idiomatic/polymorphism/from-oop-to-rust/problem-solving.html

4.2.16 解题：拆解问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0
// 问题：实现一个 GUI API

// 问题：绘图 API 的最小有用行为是什么？
pub trait DrawApi {
 fn arc(&self, center: [f32; 2], radius: f32, start_angle: f32, end_angle: f32);
 fn line(&self, start: [f32; 2], end: [f32; 2]);
}

pub struct TextDraw;

impl DrawApi for TextDraw {
 fn arc(&self, center: [f32; 2], radius: f32, start_angle: f32, end_angle: f32) {
 println!("arc of radius ")
 }

 fn line(&self, start: [f32; 2], end: [f32; 2]) { /* ... */
 }
}

// 问题：对用户而言怎样的 API 更好？

pub trait Draw {
 fn draw<T: DrawApi>(&self, surface: &mut T);
}

pub struct Rect {
 start: [f32; 2],
 end: [f32; 2],
}

impl Draw for Rect {
 fn draw<T: DrawApi>(&self, surface: &mut T) {
 surface.line([self.start[0], self.start[1]], [self.end[0], self.start[1]]);
 surface.line([self.end[0], self.start[1]], [self.end[0], self.end[1]]);
 surface.line([self.end[0], self.end[1]], [self.start[0], self.end[1]]);
 surface.line([self.start[0], self.end[1]], [self.start[0], self.start[1]]);
 }
}

你已经擅长拆解问题，但很可能习惯了先伸手拿 OOP 风格的方法。

这并不是剧烈变化，只是需要重新安排你接近问题的顺序。

4.2 从 OOP 到 Rust on 编程那些事儿

4.2.1 继承

4.2.1 继承

4.2.2 Rust 为何没有继承？

4.2.2 Rust 为何没有继承？

4.2.3 从 Rust 视角看继承

4.2.3 从 Rust 视角看继承

4.2.4 Rust 中的「继承」与父 Trait

4.2.4 Rust 中的「继承」与父 Trait

4.2.5 组合优于继承

4.2.5 组合优于继承

4.2.6 Trait 对象与动态分发

4.2.6 Trait 对象与动态分发

4.2.7 Dyn 兼容性

4.2.7 Dyn 兼容性

4.2.8 泛型 vs Trait 对象

4.2.8 泛型 vs Trait 对象

4.2.9 Trait 对象的局限

4.2.9 Trait 对象的局限

4.2.10 异构集合

4.2.10 异构集合

4.2.11 `Any` Trait

4.2.11 Any Trait

4.2.12 陷阱：过早伸手拿 `dyn Trait`

4.2.12 陷阱：过早伸手拿 dyn Trait

4.2.13 密封 Trait

4.2.13 密封 Trait

4.2.14 用枚举密封

4.2.14 用枚举密封

4.2.15 可被用户扩展的多态 Trait

4.2.15 可被用户扩展的多态 Trait

4.2.16 解题：拆解问题

4.2.16 解题：拆解问题

4.2.11 `Any` Trait

4.2.12 陷阱：过早伸手拿 `dyn Trait`