Scala 基本语法

Scala 基本语法

Scala 语法借鉴自 Java，但增加了函数式元素，并致力于简洁。主要区别包括可选的分号、类型推断和面向表达式的编程。

核心概念回顾：

• Object： class 的一个实例，具有状态 (fields) 和行为 (methods)。
• Class： 用于创建 object 的蓝图。
• Method： 与 class 或 object 关联的函数，定义行为。
• Field： 与 class 实例或 object 关联的变量，定义状态 (val 或 var)。

第一个 Scala 程序 (@main)：

Scala 3 引入了 @main 注解，作为创建可执行程序的简单方式，无需显式的 object 和 main 方法。

// Save as HelloWorld.scala
@main def helloWorld(): Unit = {
  println("Hello, Scala 3 world!")
}

编译与执行：

虽然可以使用 scalac 和 scala 命令编译和运行单个文件，但对于项目而言，使用构建工具如 sbt 是标准的做法。

使用 scalac/scala (适用于简单文件)：

$ scalac HelloWorld.scala  # Compiles to .class files
$ scala helloWorld        # Runs the main function (name after @main)

使用 sbt (项目推荐)：

# Assuming HelloWorld.scala is in src/main/scala and you have a build.sbt
$ sbt compile # Compiles the project
$ sbt run     # Compiles if needed, then runs the main class found

传统的 main 方法 (仍然有效)：

仍然可以使用包含 main 方法签名的传统 object：

// Save as LegacyHello.scala
object LegacyHello {
  def main(args: Array[String]): Unit = {
    println("Hello from traditional main!")
    // Access command-line arguments via 'args' array
    // println(s"Arguments: ${args.mkString(", ")}")
  }
}

可以使用 sbt run 或 scala LegacyHello arg1 arg2 运行。

基本语法规则：

• 大小写敏感： Scala 区分大小写 (Hello 与 hello 不同)。
• 命名约定： - Class/Trait/Object：UpperCamelCase (例如，MyClass、LoggerObject)。 - Method/Field/Variable：lowerCamelCase (例如，myMethod、userName)。 - 常量 (val 常用于此)：可以是 UpperCamelCase 或 UPPER_SNAKE_CASE。
• 文件名： 通常应与其中定义的 class 或 object 的名称匹配，以 .scala 结尾（例如，MyClass.scala）。
• 入口点： 执行从带有 @main 注解的方法或 object 中标准的 def main(args: Array[String]): Unit 方法开始。
• 分号 (;)： 通常在行尾是可选的。只有在同一行分隔多个语句时才需要。
• 块 ({})： 用于分组多个语句，构成方法、class、表达式（如 if、match、for）的主体。块的值是其最后一个表达式的值。

标识符：

赋予 class、方法、变量等的名称。Scala 有几种类型：

字母数字型：

以字母或下划线 (_) 开头，后跟字母、数字或下划线。不能使用保留关键字。$ 是保留字符。

Valid: `age`, `salary`, `_temp`, `process_data`, `Var1`
Invalid: `1stValue`, `my-var`, `$amount`

操作符型：

由一个或多个操作符字符组成（例如，+, -, *, /, :, ?, ~, #）。常用于符号方法名。

Valid: `+`, `++`, `::`, `/:`, `->`, `?`

混合型：

一个字母数字标识符后跟 _ 和一个操作符标识符。用于定义一元操作符或赋值操作符。

Valid: `unary_+` (defines prefix `+`), `vector_+=` (defines `+=` operator)

字面量型：

用反引号 (`) 括起来的任意字符串。允许使用保留关键字作为标识符或带有特殊字符的标识符。

Valid: `` `type` ``, `` `yield` ``, `` `My Var With Spaces` ``

Scala 关键字：

保留词，不能用作标识符（除非用反引号括起来）。

Common keywords: abstract, case, catch, class, def, do, else, enum, export, extends, false, final, finally, for, given, if, implicit, import, lazy, match, new, null, object, override, package, private, protected, return, sealed, super, then, this, throw, trait, true, try, type, val, var, while, with, yield.

（注意：此列表包含来自不同 Scala 版本的关键字，例如 Scala 3 的关键字如 enum、given、export、then）。

注释：

• 单行注释： 以 // 开头。行的其余部分将被忽略。

// 这是一个单行注释
val x = 10 // 代码后面的注释

• 多行注释： 以 /* 开头，以 */ 结束。可以跨多行。可以嵌套。

/* 这是一个
   多行注释。
   /* 允许嵌套注释 */
*/
val y = 20

• Scaladoc： 以 /** 开头，以 */ 结束。用于生成 API 文档。

/** Adds two integers.
 *
 * @param a The first integer.
 * @param b The second integer.
 * @return The sum of a and b.
 */
def add(a: Int, b: Int): Int = a + b

包和导入：

使用包将代码组织到命名空间中。使用 import 关键字访问其他包中的成员。

package com.mycompany.myapp // 包声明在顶部

// 导入特定成员
import scala.util.Try
import java.io.File

// 导入包中的所有成员 (通配符)
import scala.collection.mutable._

// 导入同一包中的多个成员
import scala.concurrent.{ Future, ExecutionContext }

// 导入并重命名
import java.util.{ HashMap => JavaHashMap }

class MyCode {
  val buffer: Buffer[Int] = Buffer(1, 2, 3) // Using imported Buffer
  val future: Future[String] = Future.successful("Done")
  val javaMap = new JavaHashMap[String, Int]()
}