Rust 中 实现类继承在 Rust 中，由于不支持类的继承，开发者通常通过 组合（composition）和 特性（t

在 Rust 中，由于不支持类的继承，开发者通常通过 组合（composition）和 特性（traits）来实现类似继承的功能和扩展。组合是指通过将一个结构体作为另一个结构体的字段，来复用功能。而特性则是一种定义行为的机制，可以为多个结构体实现相同的行为，从而实现类似于面向对象语言中的接口和多态。

1. 组合（Composition）

组合是一种设计模式，通过将某个结构体作为另一个结构体的字段来实现功能复用。在 Rust 中，组合可以帮助我们组合不同的功能模块，而不需要使用继承。

例子：使用组合

struct Engine {
    horsepower: u32,
}

impl Engine {
    fn start(&self) {
        println!("Engine with {} horsepower is starting...", self.horsepower);
    }
}

struct Car {
    engine: Engine,
    model: String,
}

impl Car {
    fn start(&self) {
        // 使用组合的字段来调用其方法
        self.engine.start();
        println!("Car model {} is ready to go!", self.model);
    }
}

fn main() {
    let engine = Engine { horsepower: 150 };
    let car = Car { engine, model: String::from("Toyota") };
    car.start(); // 同时启动引擎和汽车
}

在这个例子中，Car 结构体通过组合 Engine 结构体来复用 Engine 的功能，而不需要继承 Engine。这就是组合的核心思想：通过字段来包含其他类型，从而获得其行为。

2. 特性（Traits）

特性（traits）是 Rust 中用于定义共享行为的方式，类似于其他语言中的接口（interface）。你可以为多个不同的结构体实现同一个特性，这样它们可以共享相同的方法签名和行为。此外，特性还可以支持泛型，因此它们非常灵活。

例子：使用特性来实现行为

trait Drivable {
    fn drive(&self);
}

struct Car {
    model: String,
}

impl Drivable for Car {
    fn drive(&self) {
        println!("The car model {} is driving.", self.model);
    }
}

struct Bicycle {
    brand: String,
}

impl Drivable for Bicycle {
    fn drive(&self) {
        println!("The bicycle brand {} is being pedaled.", self.brand);
    }
}

fn start_trip(vehicle: &impl Drivable) {
    vehicle.drive();
}

fn main() {
    let car = Car { model: String::from("Toyota") };
    let bike = Bicycle { brand: String::from("Giant") };

    start_trip(&car);
    start_trip(&bike);
}

在这个例子中，我们定义了一个 Drivable 特性，并为 Car 和 Bicycle 两种类型实现了该特性。start_trip 函数可以接受任何实现了 Drivable 特性的类型，这实现了类似于接口的多态性。

3. 组合与特性结合

通过组合和特性结合，Rust 可以实现类似 OOP 语言中的继承与扩展。在这种模式下，我们可以通过组合来实现不同模块的功能组合，通过特性来定义共享行为，并对这些组合进行统一的接口实现。

例子：组合与特性结合

trait Drivable {
    fn drive(&self);
}

struct Engine {
    horsepower: u32,
}

impl Engine {
    fn start(&self) {
        println!("Engine with {} horsepower is starting...", self.horsepower);
    }
}

struct Car {
    engine: Engine,
    model: String,
}

impl Drivable for Car {
    fn drive(&self) {
        self.engine.start();
        println!("The car model {} is driving.", self.model);
    }
}

struct Motorcycle {
    engine: Engine,
    brand: String,
}

impl Drivable for Motorcycle {
    fn drive(&self) {
        self.engine.start();
        println!("The motorcycle brand {} is riding.", self.brand);
    }
}

fn main() {
    let car = Car { engine: Engine { horsepower: 150 }, model: String::from("Toyota") };
    let motorcycle = Motorcycle { engine: Engine { horsepower: 100 }, brand: String::from("Harley") };

    car.drive(); // 使用组合和特性
    motorcycle.drive(); // 使用组合和特性
}

在这个例子中，我们将 Engine 作为 Car 和 Motorcycle 的组成部分，通过组合 Engine 来实现它们共享的功能。同时，这两个结构体都实现了 Drivable 特性，因此它们可以通过统一的接口来使用。这种方式类似于面向对象语言中的继承和接口的结合使用，但更加灵活。

4. 特性的扩展与默认实现

特性可以通过默认实现来扩展其他类型的功能。通过为特性提供默认方法实现，所有实现了该特性的类型都可以直接使用这些默认方法，除非它们选择覆盖默认方法。

例子：带有默认实现的特性

trait Drivable {
    fn drive(&self);
    
    // 提供一个默认实现
    fn stop(&self) {
        println!("The vehicle has stopped.");
    }
}

struct Car {
    model: String,
}

impl Drivable for Car {
    fn drive(&self) {
        println!("The car model {} is driving.", self.model);
    }
}

fn main() {
    let car = Car { model: String::from("Toyota") };
    car.drive();
    car.stop(); // 调用特性中的默认实现
}

在这个例子中，Drivable 特性提供了一个默认的 stop 方法实现，Car 结构体通过实现 Drivable 特性获得了这个方法，而不需要自己实现。

5. 动态调度与特性对象

虽然 Rust 主要通过静态分发来调用方法，但也支持通过特性对象（trait objects）实现动态调度。这可以允许在运行时选择调用哪个方法，实现类似于动态语言中的多态行为。

例子：使用特性对象

trait Drivable {
    fn drive(&self);
}

struct Car {
    model: String,
}

impl Drivable for Car {
    fn drive(&self) {
        println!("The car model {} is driving.", self.model);
    }
}

struct Bicycle {
    brand: String,
}

impl Drivable for Bicycle {
    fn drive(&self) {
        println!("The bicycle brand {} is being pedaled.", self.brand);
    }
}

fn start_trip(vehicle: &dyn Drivable) {
    vehicle.drive(); // 动态分发
}

fn main() {
    let car = Car { model: String::from("Toyota") };
    let bike = Bicycle { brand: String::from("Giant") };

    start_trip(&car);
    start_trip(&bike);
}

在这个例子中，start_trip 接受一个特性对象 &dyn Drivable，在运行时决定调用 Car 或 Bicycle 的 drive 方法。这种动态调度类似于 JavaScript 的动态方法调用。

6. 总结

• 组合: 通过将其他类型作为字段包含在结构体中，实现功能模块的组合和复用。
• 特性（Traits）: 定义共享行为的接口，可以为多个类型实现相同的行为，支持默认实现和动态分发。
• 组合与特性结合: 可以实现灵活的功能扩展，类似于传统 OOP 语言中的继承和接口的结合。
• 动态调度: 通过特性对象实现运行时多态，虽然 Rust 主要基于静态分发，但也支持在运行时选择具体的实现。

这些特性让 Rust 提供了比传统 OOP 语言更灵活、更安全的方式来实现功能扩展和多态。