3.1 变量

虽然，rust有和java一样的自动判别变量类型，但它并非弱语言类型，而是一个强语言类型，笔者曾经犯过这样的错误喵

如果我们要声明一个变量，我们需要使用let关键字

let a = 100;
//在java中等效于
var a = 100;
//如果我们需要声明32位整数，那就需要在a后面补一个变量类型

let a: i32 = 100;

但事实上，虽然我们用let声明了一个变量，但我们其实无法像正常变量一样对待它

众所周知，很多程序员喜欢用变量声明常量，这是个很不好的行为

所以在rust中，用let声明的变量都是不可修改的，在初期，我们可以将它视作一种特殊的常量

如果我们真的需要一个可以变的变量，需要使用let mut关键字

let a = 1;
a = 2; //这是不被允许的
let mut b = 1;
b = 2; //这是被允许的

而在Rust中，自动类型转换也是不被允许的，所有的转换都需要手动完成<br/>

比如下列代码

let mut a: i32 = 100;
a = 100.1 //这是不被允许的
//但在Java中，是存在自动转换的
//比如我们可以让double c = 1 + 1.3，前面的int是可以直接转化为double的
//在rust中，如果需要手动转换
//比如
let a: i32 = 10;
let b: f64 = 9.5;
let c = a as f64; //将a转化为64位浮点数
let d = b as i32; //将b转化为32位整型

3.2 重影<br/>

重影指的是变量名可以被覆盖，即可以用新的变量x取覆盖旧的变量x<br/>

比如

fn main() {
    let x = 5;           // 第一个 x
    println!("x = {}", x); // 输出: x = 5
    
    let x = x + 1;       // 重影：创建新的 x，遮蔽了第一个 x
    println!("x = {}", x); // 输出: x = 6
    
    let x = x * 2;       // 再次重影
    println!("x = {}", x); // 输出: x = 12
}

对比使用let mut，重影可以做到同时修改变量类型<br/>

fn main() {
    let x = 5;          // x 是 i32
    println!("x = {}", x); // 输出: 5
    
    let x = "hello";    // 重影：x 现在是 &str
    println!("x = {}", x); // 输出: hello
    
    let x = true;       // 再次重影：x 现在是 bool
    println!("x = {}", x); // 输出: true
    
    let input = "42";           // 字符串
    let input: i32 = input.parse().unwrap(); // 重影为整数
    println!("数字: {}", input); // 输出: 数字: 42
}

我们也可以在一个小的作用域里重用变量名，但不影响这个变量在外层的值

fn main() {
    let result = calculate();
    println!("初始结果: {}", result);
    
    {
        let result = process(result); // 在内层作用域重影
        println!("处理后的结果: {}", result);
    } // 内层 result 离开作用域
    
    println!("外层结果仍然存在: {}", result); // 输出初始结果
}
fn calculate() -> i32 { 42 }
fn process(x: i32) -> i32 { x * 2 }

<br/>

3.3 常量<br/>

和C一样，常量用const声明，需要指定类型<br/>

const A: i32 = 100;

虽然看上去貌似和不可变变量差不多，但还是有一些区别的<br/>

1). 常量声明必须指定类型

2). 常量必须赋值、定义同时进行

3). 常量可以在任意位置声明，而变量只能在函数内声明