1. Scala 语言基础

Scala 语言基础详解及实践

1. Scala 简介

Scala 运行于 Java 虚拟机 (JVM) 之上，并可以与 Java 代码无缝互操作。它具有简洁的语法、强大的类型推断和丰富的特性，使其成为构建高性能、可扩展应用程序的理想选择。

2. Scala 基础语法

2.1 变量声明

Scala 使用 val 和 var 关键字声明变量。

• val 声明的变量是不可变的 (immutable)，类似于 Java 中的 final。 一旦赋值，就不能更改其值。

• var 声明的变量是可变的 (mutable)，可以更改其值。

val message: String = "Hello, Scala!" // 不可变变量
var counter: Int = 0 // 可变变量
// 类型推断，可以省略类型声明
val name = "Alice"
var age = 30
​

2.2 数据类型

Scala 拥有丰富的数据类型，包括：

• 数值类型: Byte, Short, Int, Long, Float, Double

• 字符类型: Char

• 布尔类型: Boolean

• 字符串类型: String

• Unit 类型: Unit (类似于 Java 中的 void)

• Null 类型: Null (所有引用类型的子类型，只能赋值给引用类型)

• Nothing 类型: Nothing (所有类型的子类型，通常用于表示异常抛出或永不返回的函数)

2.3 控制结构

Scala 提供了常见的控制结构，如 if-else 条件语句和 for 循环。

// if-else 条件语句
val x = 10
if (x > 0) {
  println("x is positive")
} else if (x < 0) {
  println("x is negative")
} else {
  println("x is zero")
}
// for 循环
for (i <- 1 to 5) { // 包含 5
  println(s"i = $i")
}
for (i <- 1 until 5) { // 不包含 5
  println(s"i = $i")
}
// 使用集合进行 for 循环
val numbers = List(1, 2, 3, 4, 5)
for (number <- numbers) {
  println(s"number = $number")
}
// for 循环结合条件过滤 (guard)
for (number <- numbers if number % 2 == 0) {
  println(s"Even number = $number")
}
// for 循环结合 yield 表达式 (for comprehension)
val evenNumbers = for (number <- numbers if number % 2 == 0) yield number * 2
println(s"Even numbers doubled: $evenNumbers") // 输出: Even numbers doubled: List(4, 8)
​

2.4 函数定义

Scala 使用 def 关键字定义函数。

def add(x: Int, y: Int): Int = {
  x + y
}
// 简写形式，如果函数体只有一行，可以省略花括号
def multiply(x: Int, y: Int): Int = x * y
// 无返回值函数
def greet(name: String): Unit = {
  println(s"Hello, $name!")
}
// 默认参数
def greetWithDefault(name: String = "World"): Unit = {
  println(s"Hello, $name!")
}
greetWithDefault() // 输出: Hello, World!
greetWithDefault("Scala") // 输出: Hello, Scala!
// 可变参数
def printAll(strings: String*): Unit = {
  for (str <- strings) {
    println(str)
  }
}
printAll("a", "b", "c")
​

2.5 类和对象

Scala 是一种面向对象编程语言，支持类和对象的概念。

// 定义一个类
class Person(val name: String, var age: Int) {
  def greet(): String = {
    s"Hello, my name is $name and I am $age years old."
  }
  def increaseAge(years: Int): Unit = {
    age += years
  }
}
// 创建一个对象
val person = new Person("Alice", 30)
println(person.greet()) // 输出: Hello, my name is Alice and I am 30 years old.
person.increaseAge(5)
println(person.greet()) // 输出: Hello, my name is Alice and I am 35 years old.
// 单例对象 (Singleton Object)
object MathUtils {
  val PI = 3.14159
  def square(x: Double): Double = x * x
}
println(MathUtils.PI) // 输出: 3.14159
println(MathUtils.square(5)) // 输出: 25.0
​

3. Scala 进阶特性

3.1 Case 类 (Case Classes)

Case 类是一种特殊的类，用于表示不可变的数据。它们具有以下特性：

• 自动生成 equals, hashCode, 和 toString 方法。

• 可以使用模式匹配。

• 自动生成 copy 方法，用于创建对象的副本。

case class Point(x: Int, y: Int)
val p1 = Point(1, 2)
val p2 = Point(1, 2)
println(p1 == p2) // 输出: true (因为自动生成了 equals 方法)
println(p1.toString) // 输出: Point(1,2) (因为自动生成了 toString 方法)
val p3 = p1.copy(x = 3) // 创建 p1 的副本，并将 x 坐标修改为 3
println(p3) // 输出: Point(3,2)
​

3.2 模式匹配 (Pattern Matching)

模式匹配是一种强大的特性，用于根据不同的模式匹配值。

def describe(x: Any): String = x match {
  case 1 => "One"
  case "hello" => "Hello string"
  case Point(a, b) => s"Point at ($a, $b)"
  case _ => "Something else" // 默认情况
}
println(describe(1)) // 输出: One
println(describe("hello")) // 输出: Hello string
println(describe(Point(3, 4))) // 输出: Point at (3, 4)
println(describe(true)) // 输出: Something else
​

3.3 Trait (特质)

Trait 类似于 Java 中的接口，但可以包含具体实现。类可以混入多个 trait。

trait Logger {
  def log(message: String): Unit = {
    println(s"LOG: $message")
  }
}
class Service extends Logger {
  def doSomething(): Unit = {
    log("Doing something...")
  }
}
val service = new Service()
service.doSomething() // 输出: LOG: Doing something...
​

3.4 集合 (Collections)

Scala 提供了丰富的集合库，包括 List, Set, Map 等。

val list = List(1, 2, 3, 4, 5)
val set = Set(1, 2, 3, 3, 4) // Set 中不允许重复元素
val map = Map("a" -> 1, "b" -> 2, "c" -> 3)
println(list.head) // 输出: 1
println(list.tail) // 输出: List(2, 3, 4, 5)
println(set.size) // 输出: 4
println(map("b")) // 输出: 2
// 集合操作
val doubledList = list.map(_ * 2) // 将 list 中的每个元素乘以 2
println(doubledList) // 输出: List(2, 4, 6, 8, 10)
val evenNumbersList = list.filter(_ % 2 == 0) // 过滤出 list 中的偶数
println(evenNumbersList) // 输出: List(2, 4)
val sum = list.reduce(_ + _) // 将 list 中的所有元素相加
println(sum) // 输出: 15
​

4. Scala 与 Java 互操作

Scala 可以无缝地与 Java 代码互操作。你可以在 Scala 代码中使用 Java 类库，也可以在 Java 代码中使用 Scala 类库。

// 在 Scala 中使用 Java 类
val random = new java.util.Random()
println(random.nextInt(100)) // 生成一个 0 到 99 之间的随机整数
// 在 Java 中使用 Scala 类 (需要将 Scala 代码编译成 .class 文件)
// 假设 Scala 类名为 MyScalaClass
// Java 代码:
// MyScalaClass obj = new MyScalaClass();
​

5. 总结

本文介绍了 Scala 语言的基础知识，包括变量声明、数据类型、控制结构、函数定义、类和对象、Case 类、模式匹配、Trait 和集合。通过这些基础知识，你可以开始编写简单的 Scala 程序。Scala 还有许多高级特性，例如隐式转换、类型类、Actor 模型等，可以在学习过程中逐步探索。希望本文能帮助你入门 Scala 编程。