[rust]面向对象

介绍

1. Rust虽然和面向对象编程语言（如C++、Java）在概念上有很多相似之处，但它并不是严格的面向对象编程语言
2. 面向对象编程具有封装、继承、多态和抽象这四大特点。但Rust不支持传统面向对象语言中的类继承，但是通过组合（composition）和Trait（类似于接口）实现代码复用和行为共享。
3. 在许多面向对象编程语言中，方法重载（method overloading）允许同一个类中出现多个同名但参数不同的方法。然而，Rust不支持方法重载。Rust的设计哲学更倾向于避免模糊和复杂性，要求每个函数或方法都有独特的名称。

封装

定义：封装是通过将数据和方法绑定在一起，并隐藏实现细节，保护数据免受不正当访问。

使用：通过模块(system mod)和结构体(system struct)实现。我们可以用pub关键字来控制模块、结构体和方法的可见性。

mod my_module {
    pub struct MyStruct {
        pub public_field: i32,
        private_field: i32,
    }

    impl MyStruct {
        pub fn new(public: i32, private: i32) -> MyStruct {
            MyStruct {
                public_field: public,
                private_field: private,
            }
        }

        pub fn get_private_field(&self) -> i32 {
            self.private_field
        }
    }
}

fn main() {
    let s = my_module::MyStruct::new(1, 2);
    println!("Public field: {}", s.public_field);
    // println!("Private field: {}", s.private_field); // 编译错误，无法访问私有字段
    println!("Private field via method: {}", s.get_private_field());
}

组合

通过将一个结构体嵌入到另一个结构体来实现。

struct Engine {
    horsepower: u32,
}
struct Car {
    make: String,
    model: String,
    engine: Engine,
}

fn main() {
    let engine = Engine { horsepower: 150 };
    let car = Car {
        make: "Toyota".to_string(),
        model: "Corolla".to_string(),
        engine,
    };
    println!("Car: {} {}, Horsepower: {}", car.make, car.model, car.engine.horsepower);
}

多态

多态性通过Trait对象实现，这允许我们在编译时不知道具体类型的情况下，调用相应的Trait方法。

trait Vehicle {
    fn drive(&self);
}
struct Car;

impl Vehicle for Car {
    fn drive(&self) {
        println!("Car is driving");
    }
}

struct Bike;

impl Vehicle for Bike {
    fn drive(&self) {
        println!("Bike is driving");
    }
}

fn main() {
    let vehicles: Vec<Box<dyn Vehicle>> = vec![Box::new(Car), Box::new(Bike)];

    for vehicle in vehicles {
        vehicle.drive();
    }
}