Scala 入门与实践：函数式与面向对象融合

引言

Scala 是一门运行在 Java 虚拟机上的现代多范式语言，其名称源自“Scalable Language”，意为可扩展的语言。它优雅地融合了面向对象编程与函数式编程的精髓，让开发者能够用简洁、类型安全的方式构建高并发、可维护的应用程序。本教程将带你从零开始，掌握 Scala 的核心概念，并通过实践理解两种范式的完美共存。

环境准备

安装 JDK

Scala 依赖 Java 运行环境，请确保已安装 JDK 8 或更高版本。在命令行执行 java -version 验证安装成功。

安装 Scala

推荐使用Coursier 或 Scala 官网安装包，也可直接通过 SDKMAN! 管理版本。安装完成后执行 scala -version 确认。

使用交互式环境 REPL

Scala 提供强大的交互式解释器，直接输入 scala 即可进入。你可以在其中快速测试代码片段。

构建工具 SBT

实际项目中使用 SBT (Scala Build Tool) 管理依赖与编译。安装 SBT 后，通过 sbt new scala/scala3.g8 创建模板项目。

基础语法快速预览

变量定义

Scala 鼓励使用不可变变量 (val)，同时也提供可变变量 (var)。类型推断让代码更简洁。

val name: String = "Scala"  // 显式类型
val version = 3.3           // 自动推断为 Int
var counter = 0             // 可变变量

函数定义

函数使用 def 关键字，返回类型可省略（递归函数除外）。

def greet(name: String): String = s"Hello, $name"
def add(x: Int, y: Int) = x + y  // 返回类型自动推断

控制结构

if/else 是表达式，会返回一个值。for 循环支持生成器、过滤和 yield 构建集合。

val result = if (age >= 18) "Adult" else "Minor"

val squares = for i <- 1 to 5 yield i * i

面向对象编程特性

类与构造器

类的定义紧凑，构造器参数直接放在类名后。默认访问修饰符为 public。

class Person(val name: String, var age: Int):
  def introduce(): String = s"$name is $age years old"

单例对象与伴生对象

用 object 关键字定义单例，与同名的 class 互为伴生，可以互相访问私有成员。

object MathUtils:
  val PI = 3.14159
  def square(x: Double) = x * x

// 伴生对象常用于工厂方法
class Account private (val id: Int):
  override def toString = s"Account #$id"

object Account:
  private var lastId = 0
  def create(): Account =
    lastId += 1
    new Account(lastId)

特质（Trait）与混入

trait 类似接口，但可以包含实现。支持多重继承通过混入 with 解决。

trait Logger:
  def log(msg: String): Unit = println(s"LOG: $msg")

trait TimestampLogger extends Logger:
  override def log(msg: String): Unit = super.log(s"${java.time.Instant.now} $msg")

class Service extends TimestampLogger:
  def doWork() = log("Processing...")

样例类（Case Class）

用于不可变数据建模，自动生成 equals、hashCode、toString 和模式匹配所需的方法。

case class Point(x: Int, y: Int)
val p1 = Point(1, 2)
val p2 = p1.copy(y = 5)  // Point(1,5)

函数式编程核心

一等公民函数

函数可以赋值给变量、作为参数传递或作为返回值。

val double = (x: Int) => x * 2
val numbers = List(1, 2, 3).map(double) // List(2,4,6)

高阶函数与闭包

接收或返回函数的函数称为高阶函数。闭包能捕获外部作用域的变量。

def multiplier(factor: Int): Int => Int = (x: Int) => x * factor
val triple = multiplier(3)
triple(10) // 30

不可变集合与常用操作

Scala 标准库默认提供不可变集合（immutable）。核心方法有 map、filter、flatMap、fold、reduce 等。

val fruits = List("apple", "banana", "cherry")
val lengths = fruits.map(_.length)         // List(5,6,6)
val bFruits = fruits.filter(_.startsWith("b")) // List("banana")
val totalChars = fruits.foldLeft(0)((sum, s) => sum + s.length) // 17

选项类型（Option）

用 Option 优雅处理可能缺失的值，避免空指针。

def parseInt(s: String): Option[Int] = s.toIntOption
val result = parseInt("42").map(_ * 2).getOrElse(0) // 84
val noneResult = parseInt("abc").getOrElse(-1)      // -1

模式匹配：强大的解构工具

模式匹配远不止 switch 的替代，它可以解构元组、样例类、列表，并可携带守卫条件。

def processMessage(msg: Any): String = msg match
  case s: String => s"Got string: $s"
  case i: Int if i > 0 => s"Positive integer: $i"
  case (x, y) => s"Tuple with $x and $y"
  case list @ head :: tail => s"Non-empty list starting with $head"
  case _ => "Unknown"

函数式与面向对象的融合实践

集合操作中的融合

面向对象提供数据结构，函数式提供处理方式。以下示例对用户列表进行链式操作，展示两种范式协作。

case class User(name: String, age: Int, email: Option[String])

val users = List(
  User("Alice", 30, Some("alice@example.com")),
  User("Bob", 17, None),
  User("Charlie", 25, Some("charlie@test.com"))
)

// 用面向对象方式调用集合方法，内部使用纯函数式变换
val adultEmails = users
  .filter(_.age >= 18)            // 高阶函数过滤
  .flatMap(_.email)               // 提取存在值
  .map(_.toUpperCase)             // 转换
// adultEmails: List("ALICE@EXAMPLE.COM", "CHARLIE@TEST.COM")

领域建模：特质混入函数式操作

定义一个支付领域，通过特质混入获得日志、验证等能力，同时业务逻辑用纯函数表达。

trait Payment:
  def process(amount: Double): Unit

trait LoggedPayment extends Payment:
  abstract override def process(amount: Double): Unit =
    println(s"Processing payment of $amount")
    super.process(amount)

class BankPayment extends Payment:
  override def process(amount: Double): Unit =
    println(s"Bank: $amount transferred")

// 依赖注入函数式验证
def validatedPayment(pf: Payment, amount: Double, validate: Double => Boolean): Unit =
  if validate(amount) then pf.process(amount) else println("Validation failed")

val bankPayment = new BankPayment with LoggedPayment
validatedPayment(bankPayment, 100.0, _ > 0) // 输出日志并转账

并发与Future

Scala 提供 Future 结合回调与组合子实现异步非阻塞编程，避免手动线程管理。

import scala.concurrent.{Future, Await}
import scala.concurrent.duration.*
import scala.concurrent.ExecutionContext.Implicits.global

def longComputation(i: Int): Future[Int] = Future {
  Thread.sleep(500) // 模拟耗时
  i * i
}

val future1 = longComputation(10)
val future2 = longComputation(20)

val combined = for
  r1 <- future1
  r2 <- future2
yield r1 + r2

combined.foreach(sum => println(s"Total: $sum"))
Await.result(combined, 2.seconds) // 仅用于演示阻塞等待

隐式转换与上下文参数（Scala 3）

Scala 3 用 given/using 替代隐式参数，让类型类模式更清晰。

trait Show[A]:
  def show(a: A): String

given Show[Int] with
  def show(a: Int) = s"Int: $a"

given Show[String] with
  def show(a: String) = s"String: $a"

def printValue[A](a: A)(using s: Show[A]): Unit = println(s.show(a))

printValue(42)    // Int: 42
printValue("Hi") // String: Hi

构建命令行工具实战

通过一个简单的任务列表程序，整合前面所学，感受 Scala 在日常开发中的应用。

需求描述

创建一个命令行任务管理器，支持列出任务、添加任务、标记完成、删除。数据存储在内存中，采用纯函数式状态更新。

代码实现

case class Task(id: Int, description: String, completed: Boolean = false)

class TaskManager(tasks: List[Task] = List.empty):
  def add(desc: String): TaskManager =
    val newId = if tasks.isEmpty then 1 else tasks.map(_.id).max + 1
    new TaskManager(tasks :+ Task(newId, desc))

  def complete(id: Int): TaskManager =
    new TaskManager(tasks.map(t => if t.id == id then t.copy(completed = true) else t))

  def remove(id: Int): TaskManager =
    new TaskManager(tasks.filterNot(_.id == id))

  def list(): List[String] = tasks.map { t =>
    val status = if t.completed then "[x]" else "[ ]"
    s"$status ${t.id}: ${t.description}"
  }

// 演示
val tm = TaskManager()
val afterAdd = tm.add("Learn Scala").add("Write code")
afterAdd.list().foreach(println)
val afterComplete = afterAdd.complete(1)
afterComplete.list().foreach(println)

总结与学习路径

Scala 让你能用简洁的语法驾驭复杂系统，它的函数式与面向对象融合特性使得代码表达力极强。掌握了本教程的内容，你可以进一步学习：

• 类型系统与泛型深入
• 异步流处理库（如 Akka Streams、ZIO）
• Web 框架（Play、Http4s）
• 大数据处理（Apache Spark 原生 Scala API）

开始用 Scala 写出更具声明性、可组合性和健壮性的程序吧！