scala的基本运算在 Scala 中，变量的声明和使用有其独特的语法和特性，主要分为可变变量和不可变变量，这是函数式编

在 Scala 中，变量的声明和使用有其独特的语法和特性，主要分为可变变量和不可变变量，这是函数式编程思想的体现（推荐优先使用不可变变量）。

1. 变量的声明

Scala 中通过 var（可变）和 val（不可变）关键字声明变量，基本语法：

// 不可变变量（推荐）：声明后不能修改值
val 变量名: 类型 = 初始值

// 可变变量：声明后可以修改值
var 变量名: 类型 = 初始值

示例：

// 不可变变量（val）：值不能被重新赋值
val name: String = "Scala"
// name = "Java"  // 编译错误：val 不能重新赋值

// 可变变量（var）：值可以被修改
var age: Int = 5
age = 6  // 正确：var 可以重新赋值

2. 类型推断

Scala 具有强大的类型推断能力，声明变量时可以省略类型，编译器会根据初始值自动推断类型：

val message = "Hello"  // 自动推断为 String 类型
var count = 100        // 自动推断为 Int 类型
val price = 3.14       // 自动推断为 Double 类型

3. 变量的作用域

变量的作用域与大多数编程语言类似，由代码块（{}）决定：

局部变量：在方法、函数或代码块内部声明，仅在内部可见。
成员变量：在类或对象中声明，可通过实例或对象访问。

object VariableScope {
  // 成员变量（对象级别的变量）
  val globalVar = "全局变量"

  def main(args: Array[String]): Unit = {
    // 局部变量（方法内部）
    val localVar = "局部变量"
    println(localVar)  // 正确：方法内可见
  }

  // println(localVar)  // 错误：局部变量在方法外不可见
}

4. 特殊情况：未初始化的变量

Scala 中变量声明时必须初始化，除非是抽象类中的抽象变量（无需初始化，由子类实现）：

// 错误：变量必须初始化
// var x: Int  // 编译报错

// 抽象类中的抽象变量（允许不初始化）
abstract class MyClass {
  var abstractVar: String  // 抽象变量，无初始值
}

class MySubClass extends MyClass {
  var abstractVar: String = "实现抽象变量"  // 子类必须初始化
}

5. 总结

val（不可变变量） ：一旦赋值不能修改，推荐优先使用，符合函数式编程的不可变性思想。
var（可变变量） ：可以重新赋值，用于需要修改状态的场景。
类型可省略，编译器会自动推断。
变量必须初始化（抽象变量除外）。

合理使用 val 和 var 可以提高代码的可读性和安全性，减少副作用。

scala的基本运算

Scala 支持多种基本运算，包括算术运算、关系运算、逻辑运算、位运算等，语法与 Java 等语言类似，但也有一些特性需要注意。以下是详细介绍：

1. 算术运算

适用于数值类型（Int、Double、Long 等），包括常见的加减乘除等。

运算符	描述	示例（`a=10`，`b=3`）	结果
`+`	加法	`a + b`	13
`-`	减法	`a - b`	7
`*`	乘法	`a * b`	30
`/`	除法（整数除法会取整）	`a / b`	3
`%`	取余（模运算）	`a % b`	1
`+`	字符串拼接	`"Hello" + "Scala"`	`"HelloScala"`

注意：

整数除法（如 Int 类型）会自动舍弃小数部分（不是四舍五入），例如 10 / 3 = 3，-10 / 3 = -3。
字符串与其他类型拼接时，其他类型会自动转为字符串，例如 5 + " apples" = "5 apples"。

2. 关系运算

用于比较两个值的关系，返回布尔值（Boolean：true 或 false）。

运算符	描述	示例（`a=10`，`b=3`）	结果
`==`	等于（值相等）	`a == 10`	`true`
`!=`	不等于	`a != b`	`true`
`>`	大于	`a > b`	`true`
`<`	小于	`a < b`	`false`
`>=`	大于等于	`a >= 10`	`true`
`<=`	小于等于	`b <= 2`	`false`

注意：

Scala 中 == 用于比较值是否相等（类似 Java 的 equals()），而比较对象引用是否相同需用 eq（对应 Java 的 ==）。

val s1 = "hello"
val s2 = new String("hello")
println(s1 == s2)  // true（值相等）
println(s1 eq s2)  // false（引用不同）

3. 逻辑运算

用于布尔值（Boolean）的运算，返回 Boolean 结果。

运算符	描述	示例（`x=true`，`y=false`）	结果
`&&`	逻辑与（短路）	`x && y`	`false`
`		`	逻辑或（短路）	`x	y`	`true`
`!`	逻辑非	`!x`	`false`

短路特性：

&&：若左侧为 false，则右侧表达式不会执行。
||：若左侧为 true，则右侧表达式不会执行。

val a = 5
val b = 10
println(a > 10 && (b = 20))  // 左侧为 false，右侧赋值不执行，b 仍为 10

4. 位运算

直接对整数的二进制位进行操作，适用于 Int、Long 等类型。

运算符	描述	示例（`a=6` 二进制 `110`，`b=3` 二进制 `011`）	结果（二进制）	结果（十进制）
`&`	按位与（都为 1 则 1）	`a & b`	`010`	2
`	`	按位或（有 1 则 1）	`a	b`	`111`	7
`^`	按位异或（不同则 1）	`a ^ b`	`101`	5
`~`	按位取反（0 变 1，1 变 0）	`~a`	`...11111001`	-7（补码表示）
`<<`	左移（低位补 0）	`a << 1`（6 左移 1 位）	`1100`	12
`>>`	右移（高位补符号位）	`a >> 1`（6 右移 1 位）	`011`	3
`>>>`	无符号右移（高位补 0）	`a >>> 1`（6 无符号右移 1 位）	`011`	3

5. 赋值运算

将值赋给变量，结合其他运算符可形成复合赋值。

运算符	描述	示例（`a=10`）	等价于
`=`	基本赋值	`a = 5`	-
`+=`	加后赋值	`a += 3`	`a = a + 3`
`-=`	减后赋值	`a -= 2`	`a = a - 2`
`*=`	乘后赋值	`a *= 4`	`a = a * 4`
`/=`	除后赋值	`a /= 5`	`a = a / 5`
`%=`	取余后赋值	`a %= 3`	`a = a % 3`
`&=`、`	=` 等	位运算后赋值	`a &= 2`	`a = a & 2`

6. 运算符优先级

Scala 运算符的优先级与数学规则一致，可通过括号 () 改变优先级：

最高：~、!（一元运算符）
算术运算符：*、/、% 高于 +、-
位运算：<<、>>、>>>
关系运算：==、!=、>、<、>=、<=
位逻辑运算：&、^、|
逻辑运算：&& 高于 ||
最低：赋值运算符（=、+= 等）

示例代码

object BasicOperations {
  def main(args: Array[String]): Unit = {
    // 算术运算
    val a = 10
    val b = 3
    println(a + b)  // 13
    println(a / b)  // 3（整数除法）
    println(a.toDouble / b)  // 3.333...（转为浮点数除法）

    // 关系运算
    println(a == b)  // false
    println(a != b)  // true

    // 逻辑运算
    val x = true
    val y = false
    println(x && y)  // false
    println(x || y)  // true

    // 位运算
    val c = 6  // 110
    val d = 3  // 011
    println(c & d)  // 2（010）
    println(c << 1) // 12（1100）

    // 赋值运算
    var num = 5
    num += 3  // 等价于 num = num + 3
    println(num)  // 8
  }
}

Scala 的基本运算规则与主流编程语言类似，重点注意 == 与 eq 的区别、整数除法的取整特性，以及短路逻辑运算的行为即可。