Scala基础语法 #

一、程序结构 #

1.1 基本结构 #

一个典型的 Scala 程序包含以下部分：

scala 
package com.example        // 包声明

import scala.collection.mutable.*  // 导入语句

object MyApp {             // 对象定义
  def main(args: Array[String]): Unit = {
    println("Hello, Scala!")
  }
}

1.2 Scala 3 程序入口 #

scala 
@main def app(): Unit =
  println("Hello, Scala 3!")

二、注释 #

2.1 单行注释 #

scala 
val x = 10

2.2 多行注释 #

scala 
val y = 20

2.3 文档注释 #

scala 
def add(a: Int, b: Int): Int =
  a + b

三、标识符 #

3.1 命名规则 #

  • 以字母或下划线开头
  • 后续可以是字母、数字或下划线
  • 区分大小写
  • 不能使用保留字
scala 
val name = "Scala"      // 合法
val _count = 10         // 合法
val firstName = "John"  // 合法
val firstName2 = "Jane" // 合法

3.2 非法标识符 #

scala 
val 2name = "Error"     // 非法：以数字开头
val class = "Error"     // 非法：使用保留字
val my-var = "Error"    // 非法：包含连字符

3.3 操作符标识符 #

Scala 允许使用操作符作为标识符：

scala 
val + = "plus"
val * = "multiply"
val ++ = "increment"

def + (a: Int, b: Int) = a + b

3.4 反引号标识符 #

使用反引号可以使用保留字作为标识符：

scala 
val `class` = "MyClass"
val `def` = "definition"
val `match` = "pattern match"

四、关键字 #

4.1 Scala 3 关键字 #

软关键字（Soft Keywords）：

text 
as derives end extension infix inline opaque open
overrides transparent using |  => =>> ?=>

硬关键字（Hard Keywords）：

text 
abstract case catch class def do else enum export
extends false final finally for forSome given if
implicit import lazy match new null object override
package private protected return sealed super this
throw trait true try type val var while with yield
_ : = => <- <: <% >: # @

4.2 关键字使用示例 #

scala 
if (x > 0) "positive" else "non-positive"

for (i <- 1 to 10) println(i)

try {
  riskyOperation()
} catch {
  case e: Exception => println(s"Error: ${e.getMessage}")
}

五、分号推断 #

5.1 分号可选 #

Scala 会自动推断分号，通常不需要显式添加：

scala 
val x = 10
val y = 20
val sum = x + y

5.2 需要显式分号的情况 #

多语句同行：

scala 
val x = 10; val y = 20

跨行表达式：

scala 
val result = if (condition)
  "yes"
else
  "no"

六、缩进与代码块 #

6.1 Scala 3 缩进语法 #

Scala 3 支持可选的大括号，使用缩进表示代码块：

scala 
def factorial(n: Int): Int =
  if n <= 1 then 1
  else n * factorial(n - 1)

等价于：

scala 
def factorial(n: Int): Int = {
  if (n <= 1) 1
  else n * factorial(n - 1)
}

6.2 使用 end 标记 #

scala 
def longMethod(): Unit =
  // 很多代码
  // ...
end longMethod

if condition then
  // 很多代码
end if

6.3 传统大括号语法 #

scala 
def greet(name: String): String = {
  val greeting = "Hello"
  s"$greeting, $name!"
}

七、代码规范 #

7.1 命名约定 #

类型 命名风格 示例
类/Trait PascalCase MyClass, Iterable
方法/函数 camelCase toString, mapValues
常量 UPPER_CASE MAX_VALUE
变量 camelCase userName, itemCount
包名 全小写 com.example.project

7.2 缩进规范 #

  • 使用 2 个空格缩进
  • 避免使用 Tab
scala 
def process(items: List[Int]): List[Int] =
  items
    .filter(_ > 0)
    .map(_ * 2)
    .sorted

7.3 行长度 #

  • 每行不超过 120 字符
  • 长表达式换行对齐
scala 
val result = someLongExpression
  .andAnotherExpression
  .andYetAnotherExpression

7.4 空行使用 #

scala 
class MyClass:
  
  def method1(): Int =
    val x = 10
    x * 2
  
  def method2(): String =
    "hello"

八、表达式与语句 #

8.1 表达式 #

表达式是有返回值的代码：

scala 
val x = 1 + 2           // 表达式，返回 3
val y = if (x > 0) 1 else 0  // 表达式，返回 1 或 0
val z = {               // 块表达式
  val a = 10
  val b = 20
  a + b                  // 返回 30
}

8.2 语句 #

语句是没有返回值的代码（返回 Unit）：

scala 
println("Hello")        // 语句
var counter = 0
counter += 1            // 语句

8.3 表达式导向编程 #

Scala 推荐使用表达式而非语句：

scala 
val status = if (score >= 60) "pass" else "fail"

val grade = score match
  case s if s >= 90 => "A"
  case s if s >= 80 => "B"
  case s if s >= 70 => "C"
  case s if s >= 60 => "D"
  case _ => "F"

九、包与导入 #

9.1 包定义 #

scala 
package com.example.mypackage

class MyClass

9.2 包对象 #

scala 
package object mypackage {
  val defaultName = "Unknown"
  
  def greet(name: String): String = s"Hello, $name!"
}

9.3 导入语句 #

scala 
import scala.collection.mutable.ListBuffer
import scala.collection.mutable.*  // 导入所有
import scala.collection.mutable.{ListBuffer, HashMap}  // 选择导入
import scala.collection.mutable.{ListBuffer => LB}  // 重命名
import scala.collection.mutable.{ListBuffer => _, _}  // 排除导入

9.4 隐式导入 #

以下包自动导入：

scala 
import java.lang._
import scala._
import scala.Predef._

十、类型注解 #

10.1 显式类型注解 #

scala 
val name: String = "Scala"
val age: Int = 25
val pi: Double = 3.14159
val numbers: List[Int] = List(1, 2, 3)

10.2 类型推断 #

Scala 会自动推断类型：

scala 
val name = "Scala"          // 推断为 String
val age = 25                // 推断为 Int
val pi = 3.14159            // 推断为 Double
val numbers = List(1, 2, 3) // 推断为 List[Int]

10.3 需要显式类型的情况 #

scala 
def greet(name: String): String = s"Hello, $name!"

var counter: Int = _  // 需要显式类型才能使用 _

val empty: Option[String] = None  // 需要显式类型

十一、字面量 #

11.1 整数字面量 #

scala 
val decimal = 42
val hex = 0x2A
val long = 42L

11.2 浮点字面量 #

scala 
val double = 3.14
val float = 3.14f
val scientific = 1.0e10

11.3 字符字面量 #

scala 
val char = 'A'
val unicode = '\u0041'
val escape = '\n'

11.4 字符串字面量 #

scala 
val string = "Hello"
val multiline = """This is a
multiline string"""
val interpolated = s"Hello, $name"

11.5 布尔字面量 #

scala 
val yes = true
val no = false

11.6 Null 和 Unit #

scala 
val nothing: Unit = ()
val nullRef: String = null

十二、运算符 #

12.1 算术运算符 #

scala 
val a = 10 + 5   // 加法
val b = 10 - 5   // 减法
val c = 10 * 5   // 乘法
val d = 10 / 5   // 除法
val e = 10 % 3   // 取余

12.2 关系运算符 #

scala 
val eq = 10 == 10   // 等于
val ne = 10 != 5    // 不等于
val gt = 10 > 5     // 大于
val lt = 10 < 5     // 小于
val ge = 10 >= 5    // 大于等于
val le = 10 <= 5    // 小于等于

12.3 逻辑运算符 #

scala 
val and = true && false   // 逻辑与
val or = true || false    // 逻辑或
val not = !true           // 逻辑非

12.4 位运算符 #

scala 
val and = 0xFF & 0x0F     // 按位与
val or = 0xFF | 0x0F      // 按位或
val xor = 0xFF ^ 0x0F     // 按位异或
val not = ~0xFF           // 按位取反
val left = 1 << 4         // 左移
val right = 16 >> 2       // 右移
val unsigned = -1 >>> 2   // 无符号右移

十三、总结 #

Scala 基础语法要点：

  1. 简洁性：分号可选，类型推断
  2. 表达式导向：几乎一切都是表达式
  3. 缩进语法：Scala 3 支持缩进代替大括号
  4. 命名规范：遵循 Scala 社区约定
  5. 导入灵活：支持重命名、选择、排除导入

下一步，让我们学习 变量与常量！

最后更新：2026-03-27