Java/C#背景开发者：如何在Rust中实现类似继承的行为？

作为有Java/C#背景的开发者，你肯定清楚继承在代码复用、多态实现上的核心作用。Rust虽然不支持传统的类继承，但可以通过以下几种方式达到类似的效果：

1. 使用Trait实现接口式多态 #

Trait相当于Java的接口或C#的抽象类，能定义一组方法契约，让不同类型实现这些方法，进而实现多态行为。

// 定义类似"基类接口"的Trait
trait Animal {
    fn make_sound(&self);
    fn get_name(&self) -> &str;
}

// 实现Trait的"子类"结构体
struct Dog {
    name: String,
}

impl Animal for Dog {
    fn make_sound(&self) {
        println!("{} says: Woof!", self.name);
    }

    fn get_name(&self) -> &str {
        &self.name
    }
}

struct Cat {
    name: String,
}

impl Animal for Cat {
    fn make_sound(&self) {
        println!("{} says: Meow!", self.name);
    }

    fn get_name(&self) -> &str {
        &self.name
    }
}

// 多态调用：用Trait对象接收任意实现了Animal的类型
fn let_animal_speak(animal: &dyn Animal) {
    animal.make_sound();
}

fn main() {
    let dog = Dog { name: "Buddy".to_string() };
    let cat = Cat { name: "Whiskers".to_string() };
    
    let_animal_speak(&dog);
    let_animal_speak(&cat);
}

2. 使用组合（Composition）实现代码复用 #

Rust推崇"组合优于继承"，将通用的属性和方法封装到独立结构体中，让其他结构体通过包含该结构体来复用代码，替代继承的复用逻辑。

// 提取通用属性和方法的"基础结构体"
struct BaseAnimal {
    name: String,
    age: u8,
}

impl BaseAnimal {
    fn new(name: String, age: u8) -> Self {
        BaseAnimal { name, age }
    }

    fn get_name(&self) -> &str {
        &self.name
    }

    fn get_age(&self) -> u8 {
        self.age
    }

    fn eat(&self) {
        println!("{} is eating...", self.name);
    }
}

// "子类"结构体组合BaseAnimal，扩展专属属性和方法
struct Dog {
    base: BaseAnimal,
    breed: String,
}

impl Dog {
    fn new(name: String, age: u8, breed: String) -> Self {
        Dog {
            base: BaseAnimal::new(name, age),
            breed,
        }
    }

    fn make_sound(&self) {
        println!("{} (a {}) says: Woof!", self.base.get_name(), self.breed);
    }

    // 复用基础方法并扩展逻辑
    fn eat(&self) {
        self.base.eat();
        println!("{} loves bones!", self.base.get_name());
    }
}

fn main() {
    let dog = Dog::new("Buddy".to_string(), 3, "Golden Retriever".to_string());
    println!("Name: {}", dog.base.get_name());
    dog.make_sound();
    dog.eat();
}

3. 使用枚举（Enum）实现有限类型层次 #

如果你的类型体系是封闭的（能枚举所有可能的"子类"），枚举是更高效的选择，它能将所有相关类型归为一个枚举，统一处理且性能更优。

// 定义包含所有子类的枚举
enum Animal {
    Dog { name: String, breed: String },
    Cat { name: String, favorite_toy: String },
}

impl Animal {
    fn make_sound(&self) {
        match self {
            Animal::Dog { name, .. } => println!("{} says: Woof!", name),
            Animal::Cat { name, .. } => println!("{} says: Meow!", name),
        }
    }

    fn get_name(&self) -> &str {
        match self {
            Animal::Dog { name, .. } => name,
            Animal::Cat { name, .. } => name,
        }
    }
}

fn main() {
    let dog = Animal::Dog {
        name: "Buddy".to_string(),
        breed: "Golden Retriever".to_string(),
    };
    let cat = Animal::Cat {
        name: "Whiskers".to_string(),
        favorite_toy: "Yarn".to_string(),
    };

    dog.make_sound();
    cat.make_sound();
    println!("Dog's name: {}", dog.get_name());
}

以上三种方式分别对应继承的多态、代码复用、类型层次核心需求，且避免了传统继承带来的耦合、菱形继承等问题，更符合Rust的设计哲学。

内容的提问来源于stack exchange，提问作者Mehpal