Scala

Scala-变量和数据类型-用法详解

• Scala
• 一、注释
• 二、标识符规范
• 三、变量和常量
• • • 1. 变量（`var`）
    • 2. 常量（`val`）
    • 3. 类型推断与显式声明
    • 4. `var` 和 `val` 的区别
    • 5. Scala与Java对比
    • Tips：
• 各位看客老爷万福金安，一键三连呀🤣🤣🤣 谢谢啦~

一、注释

Scala中的注释与Java是一样的，熟悉Java的小伙伴可以跳过哈🤣

• 单行注释：使用 // 来注释一行代码或行尾注释。
• 多行注释：使用 /* 和 */ 来注释多行代码。
• 文档注释：使用 /** 和 */，用于生成自动化文档，通常带有特定的格式。

1. 单行注释

// 这是一个单行注释
val x = 5 // 这是一个行尾注释

// 这是一个表示整数的变量
val number = 10

2. 多行注释

/* 这是一个多行注释
   可以跨越多行
   直到遇到结束标记 */
val y = 20

/*
   这段注释说明了代码的功能：
   下面的代码用来计算两个数的和
*/
val a = 5
val b = 3
val sum = a + b

3. 文档注释（注释生成工具）

/** 开始，*/ 结束，生成类似 JavaDoc 的注释。

二、标识符规范

1. 以字母或下划线开头，后接字母、数字、下划线

• 标识符必须以字母（a-z 或 A-Z）或下划线（_）开头，后续字符可以是字母、数字或下划线。

2. 以操作符开头，且只包含操作符（如 +, -, *, /, #, ! 等）

• 这种类型的标识符多用于操作符重载、定义自定义的二元运算符或函数。
• 不应与普通的标识符混淆，因此需要特别注意。

3. 用反引号（`）包括的任意字符串，即使是 Scala 关键字也可以

• Scala 允许使用反引号（``）括起来的字符串作为标识符，甚至可以是 Scala 的保留字或关键字（如 val, var, class, def 等）。
• 可以避免与关键字发生冲突，使其能够作为有效的标识符。
  

Scala 的 39 个关键字如下，它们是保留的语言元素，通常不能作为标识符直接使用（除非用反引号括起来）：

• abstract, case, catch, class, def, do, else, extends, final, finally, for, forSome, if, implicit, import, lazy, match, native, new, null, object, override, package, private, protected, return, sealed, super, this, throw, trait, try, type, val, var, while, with, yield

三、变量和常量

• 在 Scala 中，变量和常量的定义方式与 Java 有些不同，Scala 语言强调不可变性，推崇函数式编程，因此在处理变量和常量时有一些独特的设计。

1. 变量（var）

• var 是可变变量，用来定义可以改变值的变量。
• var 定义的变量会自动推断类型，或者你也可以显式指定类型。

显式指定类型，则必须赋一个符合该类型的初始值：

• Tips：
  • var 声明的变量可以修改其值，适用需要多次修改的情况。

2. 常量（val）

• val 用来定义不可变变量，类似于 Java 中的 final 关键字。
• 一旦为常量赋了值，就不能再修改它。

显式指定类型，依然不可以修改常量的值：

• Tips：
  • val 声明的常量一旦赋值后不能被修改。
  • val 的常量是不可变的，这也让它成为函数式编程中常见的实践方式，因为不可变数据结构有助于避免副作用和并发问题。

3. 类型推断与显式声明

• Scala 的强大之处在于类型推断🤣🤣🤣，编译器可以根据上下文自动推断变量和常量的类型。

• 咱们不需要显式声明类型，除非希望指定一个不同的类型。

（1）变量类型推断：

var x = 10  // 编译器推断 x 是 Int 类型
var name = "yushif" // 编译器推断 name 是 String 类型

（2）常量类型推断：

val pi = 3.14159  // 编译器推断 pi 是 Double 类型
val isScalaFun = true  // 编译器推断 isScalaFun 是 Boolean 类型

（3）显式指定类型：
如果需要显式指定类型，可以在变量或常量声明时指定类型：

var a: Int = 42
val b: String = "Hello"

4. var 和 val 的区别

• var（可变变量）：

  • 允许修改变量的值。
  • 使用时不需要额外的限制，适合那些可能需要改变值的场景。

    var counter = 0
    counter += 1  // counter 可以修改
    

• val（常量）：（能用常量的地方不用变量）

  • 不允许修改已经赋值的常量。声明后不可变。
  • 更符合函数式编程的理念，推荐使用 val 来定义不可变值。

    val name = "Scala"
    // name = "Java"  // 编译错误，不能改变 val 变量的值
    

在函数内部，var 和 val 的行为是一样的：

• val 用于定义不可变的局部变量。
• var 用于定义可以改变的局部变量。

def example(): Unit = {
  val a = 10  // a 是不可变的
  var b = 20  // b 是可变的
  b = 30      // 你可以修改 b 的值
  // a = 15   // 编译错误：无法修改 val 变量
  println(b)  // 输出 30
}

5. Scala与Java对比

1. 变量与常量定义的关键字：

   • 在 Java 中，变量使用 int 等类型直接定义，常量使用 final 关键字。
   • 在 Scala 中，使用 var 定义可变变量，使用 val 定义不可变常量。

2. 类型推断：

   • Java 必须显式指定类型。
   • Scala 支持类型推断，可以省略类型，编译器会自动推断。

3. 常量的不可变性：

   • 在 Java 中，final 常量一旦赋值后不能修改。
   • 在 Scala 中，val 代表常量，赋值后不能再更改。

Tips：

• 一旦类型被推断，变量的类型是固定的，不允许修改类型。

• val：声明的变量是不可变的，一旦赋值之后，值不能被修改。类型一旦推断出来，也不能被改变。

• var：声明的变量是可变的，可以修改其值，但类型一旦确定后，不能再修改类型。

  Scala 强制遵守静态类型规则，即在编译时就确定了变量的类型，之后该类型是不可变的。这与动态类型语言（如 Python 或 JavaScript）不同，在那些语言中，可以在运行时修改变量的类型。

  无论是 val 还是 var，一旦 Scala 推断出变量的类型后，该类型就不可再变。不能在后续修改变量的类型（即使是使用 var），只有值才是可以修改的。

var number = 10  // 推断为 Int
// number = "Hello"  // 错误：类型不匹配，Int 类型的变量不能赋值为 String 类型

将 "Hello" 赋给 number，会报编译错误。

• 在 Scala 中，推荐尽可能使用不可变的数据结构，因为不可变性使得并发编程更加安全，避免了共享数据带来的潜在问题。
• val 在这里发挥了重要作用，确保了数据结构一旦创建后不能改变。

//eg.
val list = List(1, 2, 3)
val newList = list :+ 4  // 创建一个新的列表，新列表与原列表不同

各位看客老爷万福金安，一键三连呀🤣🤣🤣 谢谢啦~