Rust面向对象

在一些定义下，Rust 是面向对象的；在其他定义下，Rust 不是

对象包含数据和行为

面向对象的程序是由对象组成的。一个 对象 包含数据和操作这些数据的过程。这些过程通常被称为 方法 或 操作。
在这个定义下，Rust是面向对象的

• 结构体
• 枚举

既可以定义数据也可以定义行为

封装

面向对象讲究封装，调用者无需知道如果实现，只需要知道如何使用即可，Rust的包管理、模块管理、pub关键字、函数fn，trait这些符合封装的思想

继承

继承（Inheritance）是一个很多编程语言都提供的机制，一个对象可以定义为继承另一个对象定义中的元素，这使其可以获得父对象的数据和行为，而无需重新定义。
从这里看，Rust不是面向对象的，因为Rust没有继承只有实现（trait）

多态

多态是面向对象的一个重要特征,指同一类事物同时具有多种形态,即同一类事物,在不同时刻,代表的对象不一样,指的是对象的多种形态。
从这里看Rust也是面向对象的，通过实现trait使得结构体或枚举具备多形态

实现面向对象

一个简单登录案例，用户输入用户名密码，进行校验

书写最外层逻辑

我们需要用户名和密码，构建一个User对象，使用new方法，通过userService中的login方法进行校验

use crate::user::User;

mod userService;
mod user;

fn main() {
    //服务逻辑
    let username = "testuser1".to_string();
    let password = "testpassword".to_string();
    let user = User::new(username, password);
    match userService::login(user) {
        Ok(user) => println!("{:#?}", user),
        Err(e) => println!("{:?}", e)
    }

}

userService

use crate::user::{User};

const CHECK_USERNAME: &str = "testuser";
const CHECK_PASSWORD: &str = "testpassword";

pub fn login(user: User) -> Result<User, Box<&'static str>> {
    let username = user.get_username();
    let password = user.get_password();
    return if username == CHECK_USERNAME {
        if password == CHECK_PASSWORD {
            Ok(User::new(username.to_string(), password.to_string()))
        } else {
            Err(Box::new("password error"))
        }
    } else {
        Err(Box::new("username error"))
    };
}

User

#[derive(Debug,Clone)]
pub struct User {
    username: String,
    password: String,
}

impl User {
    pub fn new(username: String, password: String) -> Self {
        User {
            username,
            password,
        }
    }
    pub fn newNoArgs() -> Self {
        User {
            username: String::new(),
            password: String::new(),
        }
    }
    pub fn get_username(&self) -> &str {
        &self.username
    }
    pub fn get_password(&self) -> &str {
        &self.password
    }
}