rust学习十八.1、RUST的OOP和简单示例

很可惜，出于一些理由，rust抛弃了OOP的核心特性之一：继承

其中一个理由应该是至关重要的，但是解释的比较模糊：继承增加了复杂性

的确，继承会让rust编译器变得更加复杂。rust编译器虽然足够体贴，但是它偏慢的编译速度也是很多人所吐槽的。

在我对rust编译了解更多之前，我对这个理由无法给出更加详细的描述，不过我能够理解。说实话，编写这样的编译器已经足够复杂，如果还要

考虑到继承，大概这种复杂度会让编译器开发者崩溃。

至于其它的理由，例如认为组合足够好用，我觉得有些牵强了！

总之，rust对oop的支持主要体现在封装和多态。

而所谓的封装，在rust中主要体现在类似java对象的类型:struct,enum中,尤其是struct。

在rust中，struct的地位类似于java的Object。

所谓的多态，主要体现在特质(trait),这个时候的特质就类似于java,c++的接口(interface)

只不过，rust的这个特质是java的接口的阉割版本。

rust的特质作为接口存在的时候，只有以下两个功能：

没有实现的方法定义
具有默认实现的方法，类似java接口的默认函数.但是后者的默认函数，有静态，私有，默认私有等四种，这是因为前者没有继承的缘故

闲言少叙，总之rust对oop的支持大概就是这样了。

一、简单示例

animals.rs

pub mod animals{
    
    pub trait Animal{
        fn eat(&self,food:&String);
        fn run(&self);
        fn sleep(&mut self);
        fn is_wakeup(&self)->bool;
        fn wakeup(&mut self);
     }

    pub struct Dog{
        name:String,
        state:bool
    }

    impl Dog{
        pub fn new(name:String)->Self{
            Dog{name,state:true}
        } 
    }

    impl Animal for Dog{
        fn eat(&self,food:&String){
            if !self.is_wakeup(){
                println!("{} 正在睡觉...请不要打扰我，等醒了再吃",self.name);
                return;
            }
            if  food=="骨头"{
                println!("{} 正在吃{}",self.name,food); 
            }
            else{
                println!("{} 不吃{}",self.name,food); 
            }
        }
        fn run(&self){
            if !self.is_wakeup(){
                println!("{} 正在睡觉...请不要打扰我，等醒了再跑",self.name);
                return;
            }
            println!("{} is running",self.name);
        }
        fn sleep(&mut self){
            println!("{} is sleeping",self.name);
            self.state=false;
        }
        fn is_wakeup(&self)->bool{
            self.state
        }
        fn wakeup(&mut self){
            println!("{} 起来！",self.name);   
            self.state=true;
        }
    }

    pub struct Cat{
        name:String,
        state:bool
    }

    impl Cat{
        pub fn new(name:String)->Self{
            Cat{name,state:true}
        } 
    }

    impl Animal for Cat{
        fn eat(&self,food:&String){
            if !self.is_wakeup(){
                println!("{} 正在睡觉...",self.name);
                return;
            }
            if food=="鱼"{
                println!("{} 正在吃{}",self.name,food);
            }else{
                println!("{} 不吃{}",self.name,food);
            }
        }
        fn run(&self){
            if !self.is_wakeup(){
                println!("{} 正在睡觉...请不要打扰我，等醒了再跑",self.name);
                return;
            }
            println!("{} is running",self.name);
        }
        fn sleep(&mut self){
            println!("{} is sleeping",self.name);
            self.state=false;
        }
        fn is_wakeup(&self)->bool{
            self.state 
        }
        fn wakeup(&mut self){
            println!("{} 起来！",self.name);   
            self.state=true;
        }
    }

 }

main.rs

mod animals;

use animals::animals::{Animal, Dog, Cat};

fn main(){
   
   let mut dog= Dog::new(String::from("小虎"));
   let mut cat= Cat::new(String::from("小白"));
   dog.run();
   cat.run();
   dog.sleep();
   cat.sleep();
   dog.run();
   cat.run();
   //
   dog.wakeup();
   cat.wakeup();

   let fish=String::from("骨头");
   dog.eat(&fish);
   cat.eat(&fish);

   let bone=String::from("鱼");
   dog.eat(&bone);
   cat.eat(&bone);
}

测试下：

rust学习十八.1、RUST的OOP和简单示例

如果用上继承，那么is_wakeup函数完全不需要写两遍。

二、小结

总之，rust对于oop的支持主要体现两点：

封装-靠struct,enum
多态-通用类型+特质

也许某天，rust会把特质设计的更体贴（复杂），但可能性不是太大，盖因rustc已经足够复杂了。