Scala 基础语法

本章将介绍 Scala 的基础语法规则，包括程序结构、注释、标识符、关键字等核心概念。

程序结构

Hello World 程序

让我们从经典的 Hello World 程序开始：

// Scala 3 风格（推荐）
@main def hello(): Unit =
  println("Hello, World!")

// 或者传统的 main 方法
object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello, World!")
  }
}

程序组成部分

一个 Scala 程序通常包含以下部分：

1. 包声明（可选）
2. 导入语句（可选）
3. 类、对象、特征定义
4. 方法和函数定义

// 1. 包声明
package com.example.myapp

// 2. 导入语句
import scala.collection.mutable.ListBuffer
import java.util.Date

// 3. 对象定义
object MyApp {
  // 4. 方法定义
  def main(args: Array[String]): Unit = {
    println("My Scala Application")
  }
}

注释

Scala 支持三种类型的注释：

单行注释

// 这是单行注释
val x = 10  // 行末注释

多行注释

/*
 * 这是多行注释
 * 可以跨越多行
 */
val y = 20

/* 简单的多行注释 */

文档注释

/**
 * 这是文档注释，用于生成 API 文档
 * @param name 用户名
 * @param age 年龄
 * @return 格式化的用户信息
 */
def formatUser(name: String, age: Int): String = {
  s"User: $name, Age: $age"
}

标识符

标识符用于命名变量、方法、类等程序元素。

标识符规则

1. 字母数字标识符：以字母或下划线开头，后跟字母、数字或下划线

val name = "Alice"
val user_age = 25
val MAX_SIZE = 100
val _private = "hidden"

2. 操作符标识符：由操作符字符组成

val + = "plus"
val :: = "cons"
val <=> = "compare"

3. 混合标识符：字母数字标识符后跟下划线和操作符标识符

val unary_+ = "positive"
val myList_+ = "append"

4. 字面量标识符：用反引号包围的任意字符串

val `class` = "reserved word"
val `my variable` = "with spaces"
val `2nd-item` = "starts with number"

命名约定

// 变量和方法：小驼峰命名
val firstName = "John"
def calculateTotal() = 100

// 常量：大写字母和下划线
val MAX_RETRY_COUNT = 3
val DEFAULT_TIMEOUT = 30

// 类和特征：大驼峰命名
class UserAccount
trait Serializable

// 包：小写字母
package com.example.utils

关键字

Scala 的保留关键字不能用作标识符：

基本关键字

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

Scala 3 新增关键字

enum        export      given       then        using

软关键字

这些在特定上下文中有特殊含义：

as          derives     end         extension   infix
inline      opaque      open        transparent using

字面量

整数字面量

val decimal = 123        // 十进制
val hex = 0xFF          // 十六进制
val octal = 0o77        // 八进制（Scala 3）
val binary = 0b1010     // 二进制（Scala 3）
val long = 123L         // Long 类型

浮点数字面量

val double1 = 3.14
val double2 = 1.23e-4   // 科学计数法
val float = 3.14f       // Float 类型
val double3 = 3.14d     // 显式 Double 类型

字符字面量

val char1 = 'A'
val char2 = '\n'        // 换行符
val char3 = '\u0041'    // Unicode 字符 'A'

字符串字面量

// 普通字符串
val str1 = "Hello, World!"

// 包含转义字符的字符串
val str2 = "Line 1\nLine 2\tTabbed"

// 原始字符串（三重引号）
val str3 = """This is a
             |multi-line
             |string""".stripMargin

// 字符串插值
val name = "Alice"
val age = 25
val str4 = s"Name: $name, Age: $age"
val str5 = s"Next year: ${age + 1}"

// 格式化字符串
val str6 = f"Pi is approximately ${math.Pi}%.2f"

// 原始字符串插值
val path = raw"C:\Users\$name\Documents"

布尔字面量

val isTrue = true
val isFalse = false

符号字面量

val symbol1 = Symbol("name")
val symbol2 = 'name  // 简写形式（已弃用）

操作符

算术操作符

val a = 10
val b = 3

val sum = a + b        // 13
val diff = a - b       // 7
val product = a * b    // 30
val quotient = a / b   // 3
val remainder = a % b  // 1

关系操作符

val x = 5
val y = 10

val equal = x == y      // false
val notEqual = x != y   // true
val less = x < y        // true
val greater = x > y     // false
val lessEqual = x <= y  // true
val greaterEqual = x >= y // false

逻辑操作符

val p = true
val q = false

val and = p && q        // false
val or = p || q         // true
val not = !p            // false

位操作符

val a = 12  // 1100 in binary
val b = 10  // 1010 in binary

val bitwiseAnd = a & b  // 8 (1000)
val bitwiseOr = a | b   // 14 (1110)
val bitwiseXor = a ^ b  // 6 (0110)
val bitwiseNot = ~a     // -13
val leftShift = a << 1  // 24
val rightShift = a >> 1 // 6

赋值操作符

var x = 10
x += 5    // x = x + 5, 结果是 15
x -= 3    // x = x - 3, 结果是 12
x *= 2    // x = x * 2, 结果是 24
x /= 4    // x = x / 4, 结果是 6
x %= 4    // x = x % 4, 结果是 2

表达式和语句

表达式

在 Scala 中，几乎所有东西都是表达式（有返回值）：

// 简单表达式
val result1 = 2 + 3  // 5

// 条件表达式
val result2 = if (x > 0) "positive" else "non-positive"

// 块表达式
val result3 = {
  val a = 10
  val b = 20
  a + b  // 块的最后一个表达式是返回值
}

// 方法调用表达式
val result4 = "hello".toUpperCase()

语句 vs 表达式

// 表达式（有返回值）
val x = 42                    // 返回 Unit
val y = if (x > 0) 1 else 0  // 返回 Int

// 语句（主要用于副作用）
println("Hello")              // 返回 Unit
var counter = 0
counter += 1                  // 返回 Unit

代码块和作用域

代码块

val result = {
  val x = 10
  val y = 20
  val z = x + y
  z * 2  // 块的返回值
}  // result = 60

作用域规则

val outer = "outer"

def example(): Unit = {
  val inner = "inner"
  
  {
    val nested = "nested"
    println(outer)   // 可以访问
    println(inner)   // 可以访问
    println(nested)  // 可以访问
  }
  
  // println(nested)  // 错误：nested 不在作用域内
}

方法定义语法

基本方法定义

// 有参数和返回类型
def add(x: Int, y: Int): Int = {
  x + y
}

// 简化形式（单表达式）
def multiply(x: Int, y: Int): Int = x * y

// 无参数方法
def getCurrentTime(): Long = System.currentTimeMillis()

// 无参数方法（可省略括号）
def pi: Double = 3.14159

方法参数

// 默认参数
def greet(name: String, greeting: String = "Hello"): String = {
  s"$greeting, $name!"
}

// 命名参数调用
val message1 = greet("Alice")
val message2 = greet("Bob", "Hi")
val message3 = greet(greeting = "Hey", name = "Charlie")

// 可变参数
def sum(numbers: Int*): Int = {
  numbers.sum
}

val total = sum(1, 2, 3, 4, 5)

类型注解

变量类型注解

// 显式类型注解
val name: String = "Alice"
val age: Int = 25
val height: Double = 5.6

// 类型推断（推荐）
val name2 = "Bob"        // 推断为 String
val age2 = 30           // 推断为 Int
val height2 = 5.8       // 推断为 Double

方法类型注解

// 返回类型注解
def calculate(x: Int, y: Int): Int = x + y

// 复杂类型注解
def processData(data: List[String]): Map[String, Int] = {
  data.groupBy(identity).view.mapValues(_.length).toMap
}

导入语句

基本导入

import scala.collection.mutable.ListBuffer
import java.util.Date
import java.io.{File, FileReader}  // 导入多个类

通配符导入

import scala.collection.mutable._  // 导入包中所有内容
import java.util.{Date, Calendar, _}  // 导入指定类和其他所有内容

重命名导入

import java.util.{Date => JavaDate}
import scala.collection.mutable.{Map => MutableMap}

val now = new JavaDate()
val map = MutableMap[String, Int]()

隐藏导入

import java.util.{Date => _, _}  // 导入除 Date 外的所有内容

相对导入

package com.example.app

import model._           // 导入 com.example.app.model 包
import util.StringUtils  // 导入 com.example.app.util.StringUtils

包声明

基本包声明

package com.example.myapp

class MyClass {
  // 类定义
}

嵌套包

package com.example {
  package myapp {
    class MyClass
  }
  
  package utils {
    class Helper
  }
}

包对象

package object myapp {
  val VERSION = "1.0.0"
  def utility(): String = "helper function"
}

// 在包内可以直接使用
package myapp
class MyClass {
  println(VERSION)  // 直接访问包对象中的成员
}

练习

练习 1：基础语法

创建一个程序，包含以下内容：

// 1. 定义一个计算器对象
object Calculator {
  
  // 2. 定义基本运算方法
  def add(a: Double, b: Double): Double = a + b
  def subtract(a: Double, b: Double): Double = a - b
  def multiply(a: Double, b: Double): Double = a * b
  def divide(a: Double, b: Double): Double = {
    if (b != 0) a / b
    else throw new IllegalArgumentException("Division by zero")
  }
  
  // 3. 主方法
  def main(args: Array[String]): Unit = {
    val x = 10.0
    val y = 3.0
    
    println(s"$x + $y = ${add(x, y)}")
    println(s"$x - $y = ${subtract(x, y)}")
    println(s"$x * $y = ${multiply(x, y)}")
    println(s"$x / $y = ${divide(x, y)}")
  }
}

练习 2：字符串处理

object StringProcessor {
  def processText(text: String): Unit = {
    // 使用字符串插值
    println(s"Original: $text")
    println(s"Length: ${text.length}")
    println(s"Uppercase: ${text.toUpperCase}")
    println(s"Lowercase: ${text.toLowerCase}")
    
    // 使用原始字符串
    val pattern = raw"\d+"
    println(s"Pattern: $pattern")
    
    // 使用格式化字符串
    val percentage = 0.856
    println(f"Percentage: ${percentage * 100}%.2f%%")
  }
  
  def main(args: Array[String]): Unit = {
    processText("Hello, Scala World!")
  }
}

总结

本章介绍了 Scala 的基础语法，包括：

• 程序结构：包声明、导入、类/对象定义
• 注释：单行、多行、文档注释
• 标识符：命名规则和约定
• 字面量：各种数据类型的字面量表示
• 操作符：算术、关系、逻辑、位操作符
• 表达式：Scala 的表达式导向特性
• 方法定义：基本语法和参数处理
• 类型系统：类型注解和推断
• 导入和包：模块化组织代码

掌握这些基础语法是学习 Scala 的重要基础。在下一章中，我们将深入学习 Scala 数据类型，了解 Scala 丰富的类型系统。