变量

定义

变量是一种使用方便的占位符，用于引用计算机内存地址,变量创建后会占用一定的内存空间

var和val的区别

• var:用于声明可变变量。如果一个变量是用var声明的，那这个变量既可访问也可修改
• val:用于声明不可变变量。如果一个变量是用val声明的，那这个变量只可访问不可修改

可声明指定类型

1.声明一个带类型的变量的语法格式:

       var/val 变量名 ：类型
      
      
    例：
    object VariableExample {
      def main(args: Array[String]): Unit = {
        // 声明不可变变量
        val immutableVariable: Int = 10
        println(s"Immutable Variable: $immutableVariable")

        // 声明可变变量
        var mutableVariable: Int = 20
        println(s"Mutable Variable: $mutableVariable")

        // 修改可变变量的值
        mutableVariable = 30
        println(s"Updated Mutable Variable: $mutableVariable")

        // 不可变变量不能被重新赋值，会导致编译错误
        // immutableVariable = 15 // Uncommenting this line will cause a compilation error
      }
    }

2.一行声明多个变量的语法格式:

var/val 变量1,变量2,... = 变量值
        
        
    例：
    object MultipleVariables {
      def main(args: Array[String]): Unit = {
        // 同时声明多个不可变变量
        val a, b, c: Int = 5
        println(s"a: $a, b: $b, c: $c")

        // 同时声明多个可变变量
        var x, y, z: Int = 10
        println(s"x: $x, y: $y, z: $z")

        // 修改可变变量的值
        x = 20
        y = 30
        z = 40
        println(s"Updated x: $x, y: $y, z: $z")
      }
    }

变量命名规范

合法字符：

• 变量名必须以字母（A-Z 或 a-z）或下划线（_）开头。
• 后续字符可以是字母、数字（0-9）或下划线。
• 变量名不能是Scala的关键字。

驼峰命名法：

• 变量名通常采用驼峰命名法，即第一个单词以小写字母开头，后续单词的首字母大写。
• 例如：myVariableName, userAge, accountBalance。

避免使用单字符变量名：

• 除了常见的计数器变量（如i, j, k）外，应尽量避免使用单字符变量名，以提高代码的可读性。

有意义的变量名：

• 变量名应能清晰地表达其用途或含义，避免使用模糊或无意义的名称。
• 例如：val age: Int = 25 优于 val a: Int = 25。

Scala特有命名规范：

• 尽量不要使用以下划线开头的变量名，这通常用于标识内部或私有变量。
• 可以使用字母和符号的组合来命名函数和方法，但这在变量命名中很少见。
• 避免使用类似运算符的符号组合（如++，--）作为变量名，这会使代码难以阅读和理解。

变量类型引用

在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。

所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。

• 显式类型声明：明确指定变量的类型。
• 类型推断：省略类型声明，由编译器推断类型。

Scala 的类型推断机制可以自动确定变量的类型，因此我们可以省略类型声明：

val inferredInt = 42  // 编译器推断为 Int
val inferredDouble = 3.14  // 编译器推断为 Double
val inferredString = "Hello, Scala!"  // 编译器推断为 String
val inferredBoolean = true  // 编译器推断为 Boolean

类型推断使代码更加简洁，但在复杂场景中，显式声明类型可以避免混淆。

显式类型声明时，在变量名后跟上冒号和数据类型：

val explicitInt: Int = 42
val explicitDouble: Double = 3.14
val explicitString: String = "Hello, Scala!"
val explicitBoolean: Boolean = true

显式声明有助于提高代码的可读性和维护性，特别是在类型不容易推断或容易混淆的情况下。

  object VariableTypesExample {
      def main(args: Array[String]): Unit = {
        // 显式类型声明
        val explicitInt: Int = 42
        val explicitDouble: Double = 3.14
        val explicitString: String = "Hello, Scala!"
        val explicitBoolean: Boolean = true

    // 类型推断
    val inferredInt = 42  // 编译器推断为 Int
    val inferredDouble = 3.14  // 编译器推断为 Double
    val inferredString = "Hello, Scala!"  // 编译器推断为 String
    val inferredBoolean = true  // 编译器推断为 Boolean

    // 可变变量
    var mutableInt: Int = 10
    println(s"Initial mutableInt: $mutableInt")
    mutableInt = 20  // 修改变量值
    println(s"Updated mutableInt: $mutableInt")

    // 输出所有变量
    println(s"Explicit Int: $explicitInt")
    println(s"Explicit Double: $explicitDouble")
    println(s"Explicit String: $explicitString")
    println(s"Explicit Boolean: $explicitBoolean")

    println(s"Inferred Int: $inferredInt")
    println(s"Inferred Double: $inferredDouble")
    println(s"Inferred String: $inferredString")
    println(s"Inferred Boolean: $inferredBoolean")
      }
    }