Scala-注释、标识符、变量与常量-用法详解

Scala

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

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

一、注释

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

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

1. 单行注释

scala 复制代码

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

scala 复制代码

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

2. 多行注释

scala 复制代码

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

scala 复制代码

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

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

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

二、标识符规范

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

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

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

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

用反引号（`）包括的任意字符串，即使是 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）变量类型推断：

scala 复制代码

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

（2）常量类型推断：

scala 复制代码

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

（3）显式指定类型：

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

scala 复制代码

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

4. `var` 和 `val` 的区别

var（可变变量）：
- 允许修改变量的值。
- 使用时不需要额外的限制，适合那些可能需要改变值的场景。
  scala 复制代码
```
var counter = 0
counter += 1  // counter 可以修改
```
val（常量） ：（能用常量的地方不用变量）
- 不允许修改已经赋值的常量。声明后不可变。
- 更符合函数式编程的理念，推荐使用 val 来定义不可变值。
  scala 复制代码
```
val name = "Scala"
// name = "Java"  // 编译错误，不能改变 val 变量的值
```

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

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

scala 复制代码

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

5. Scala与Java对比

语言	关键字	变量定义	常量定义
Java	`int`	`int a = 10;`	`final int b = 20;`
Scala	`var`	`var i: Int = 10` 或 `var i = 10`	`val j: Int = 20` 或 `val j = 20`

变量与常量定义的关键字：
- 在 Java 中，变量使用 int 等类型直接定义，常量使用 final 关键字。
- 在 Scala 中，使用 var 定义可变变量，使用 val 定义不可变常量。
类型推断：
- Java 必须显式指定类型。
- Scala 支持类型推断，可以省略类型，编译器会自动推断。
常量的不可变性：
- 在 Java 中，final 常量一旦赋值后不能修改。
- 在 Scala 中，val 代表常量，赋值后不能再更改。

Tips：

一旦类型被推断，变量的类型是固定的，不允许修改类型。
val ：声明的变量是不可变的，一旦赋值之后，值不能被修改。类型一旦推断出来，也不能被改变。
var：声明的变量是可变的，可以修改其值，但类型一旦确定后，不能再修改类型。

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

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

scala 复制代码

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

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

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

scala 复制代码

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

Scala-注释、标识符、变量与常量-用法详解

Scala

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

一、注释

二、标识符规范

三、变量和常量

1. 变量（var）

2. 常量（val）

3. 类型推断与显式声明

4. var 和 val 的区别

5. Scala与Java对比

Tips：

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

1. 变量（`var`）

2. 常量（`val`）

4. `var` 和 `val` 的区别