Scala 单例对象：object 关键字

Scala 是一门融合了面向对象和函数式编程范式的语言。在 Scala 中，object 关键字用于定义单例对象——在整个应用程序中仅有唯一实例的类。这是 Scala 替代 Java 静态成员的核心机制，也是 Scala 程序组织的基石之一。

1. 理解单例对象的基本概念

单例对象的核心特征很简单：JVM 加载该对象时，只会创建唯一一个实例。这个实例在程序运行期间始终存在，任何地方对其的引用都指向同一个对象。

与 Java 的 static 关键字不同，Scala 没有静态成员的概念。当需要静态方法或静态字段时，Scala 开发者使用 object 来实现。这种设计让 Scala 保持了纯面向对象的特性——所有成员都属于某个对象实例，而非类本身。

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

  val PI = 3.141592653589793
}

// 调用单例对象的方法
println(MathUtils.factorial(5))  // 120
println(MathUtils.PI)             // 3.141592653589793

上面的代码定义了一个名为 MathUtils 的单例对象，其中包含了计算阶乘的方法和圆周率常量。直接通过对象名访问其成员，无需创建任何实例，这与 Java 中调用 MathUtils.factorial() 的体验类似，但底层机制完全不同。

2. object 与 class 的核心区别

在 Scala 中，object 和 class 是两种互补的定义方式，理解它们的区别至关重要。

class 用于描述一类事物的共同属性和行为，可以根据需要创建任意数量的实例。而 object 本质上就是一个类，只不过它的实例化由语言运行时自动管理，且全局唯一。

class User(val name: String, val age: Int) {
  def greet(): String = s"Hello, I'm $name"
}

// 创建多个 class 实例
val alice = new User("Alice", 30)
val bob = new User("Bob", 25)

// 单例 object 只有一个
object Database {
  def connect(): Unit = println("Connected to database")
}

Database.connect()  // 直接调用，无需实例化
```

---

## 3. 用单例对象组织工具方法和常量

单例对象最常见的用途是**承载工具方法和全局常量**。这种模式将相关的功能集中管理，避免了静态导入的混乱，同时保持了代码的模块化。

在实际项目中，经常会遇到一组相关的工具函数。将它们放在同一个单例对象中，既便于组织，也便于维护。例如，处理日期格式化的工具类：

```scala
object DateFormatter {
  private val inputPattern = "yyyy-MM-dd"
  private val outputPattern = "dd/MM/yyyy"
  
  def format(dateString: String): String = {
    val input = java.time.LocalDate.parse(dateString, 
      java.time.format.DateTimeFormatter.ofPattern(inputPattern))
    input.format(java.time.format.DateTimeFormatter.ofPattern(outputPattern))
  }
  
  def isValid(dateString: String): Boolean = {
    try {
      java.time.LocalDate.parse(dateString, 
        java.time.format.DateTimeFormatter.ofPattern(inputPattern))
      true
    } catch {
      case _: Exception => false
    }
  }
}

println(DateFormatter.format("2024-03-15"))  // 15/03/2024
println(DateFormatter.isValid("2024-13-01")) // false
```

单例对象的成员可以是 `private` 的，外部代码只能访问公开的 `def`。这种封装机制与普通类完全一致，让你可以精确控制哪些成员暴露给外部使用。

---

## 4. 单例对象与状态管理

单例对象的另一个重要用途是**持有程序级别的共享状态**。由于整个 JVM 中只有单例对象的一个实例，它的字段在所有代码路径中共享同一份数据。

这个特性在实现配置管理、全局计数器、缓存等场景时非常有用。但需要注意的是，单例对象的状态在并发环境下可能导致竞态条件，Scala 提供了多种并发安全机制来处理这个问题。

```scala
object Configuration {
  private var settings: Map[String, String] = Map()
  
  def update(key: String, value: String): Unit = {
    settings = settings + (key -> value)
  }
  
  def get(key: String): Option[String] = settings.get(key)
  
  def loadFromEnv(): Unit = {
    sys.env.foreach { case (k, v) =>
      if (k.startsWith("APP_")) {
        update(k, v)
      }
    }
  }
}

Configuration.update("debug", "true")
Configuration.update("timeout", "30")
println(Configuration.get("timeout"))  // Some(30)
```

状态变化通过 `var` 字段和不可变 `Map` 的配合来实现。每次更新都创建新的 `Map` 实例，虽然牺牲了一些性能，但避免了可变状态的潜在风险，这是 Scala 函数式编程风格的体现。

---

## 5. 伴生对象与伴生类

`object` 还有一个高级用法：当 `object` 和 `class` 具有相同名称时，它们互为**伴生对象**和**伴生类**。这种关系让两者可以访问彼此的私有成员，实现一些强大的设计模式。

伴生对象最经典的应用是**工厂方法模式**。将类的构造逻辑放在伴生对象中，可以控制实例的创建过程，甚至返回子类实例。

```scala
class Circle(val radius: Double) {
  def area: Double = Circle.PI * radius * radius
}

object Circle {
  private val PI = 3.14159
  
  def apply(radius: Double): Circle = new Circle(radius)
  
  def createUnitCircle(): Circle = new Circle(1.0)
}

// 使用伴生对象的工厂方法
val c = Circle(5.0)  // 等价于 new Circle(5.0)
println(c.area)       // 78.53975
```

注意 `Circle(5.0)` 这种写法。通过在伴生对象中定义 `apply` 方法，Scala 允许你使用类似函数调用的语法来创建对象。这种语法糖让代码更加简洁，也符合 Scala 的惯用法。

伴生对象和伴生类之间没有继承关系，但**可以相互访问私有成员**。这在需要隐藏实现细节同时提供公共接口时非常有用。

---

## 6. 用伴生对象实现工厂模式

工厂模式是面向对象设计中常用的创建型模式。在 Scala 中，伴生对象是实现工厂模式的理想载体，因为工厂方法可以返回更具体的子类型，而调用者只需面向抽象编程。

```scala
trait Shape {
  def describe(): String
}

class Rectangle(val width: Double, val height: Double) extends Shape {
  def describe(): String = s"Rectangle ${width}x${height}"
}

class Triangle(val a: Double, val b: Double, val c: Double) extends Shape {
  def describe(): String = s"Triangle sides: $a, $b, $c"
}

object Shape {
  def createRectangle(w: Double, h: Double): Shape = new Rectangle(w, h)
  def createTriangle(a: Double, b: Double, c: Double): Shape = new Triangle(a, b, c)

  // 更灵活的工厂方法
  def apply(shapeType: String, params: Double*): Shape = shapeType match {
    case "rect" => new Rectangle(params(0), params(1))
    case "tri"  => new Triangle(params(0), params(1), params(2))
    case _      => throw new IllegalArgumentException(s"Unknown shape: $shapeType")
  }
}

val rect = Shape("rect", 4.0, 5.0)
val tri = Shape("tri", 3.0, 4.0, 5.0)
println(rect.describe())  // Rectangle 4.0x5.0
println(tri.describe())   // Triangle sides: 3.0, 4.0, 5.0

这种实现方式让创建逻辑集中管理，便于修改和扩展。如果需要增加新的形状，只需在伴生对象中添加新方法，而调用代码无需改变。

7. Application 特质与程序入口

Scala 程序需要一个入口点来启动执行。传统上使用 main 方法，而在单例对象中可以继承 scala.App 特质，从而省略显式的 main 方法定义。

object MyProgram extends App {
  println("程序开始执行")

  val args = this.args  // 通过 App 特质获取命令行参数
  if (args.isEmpty) {
    println("请提供参数")
  } else {
    args.foreach(println)
  }

  println("程序执行完毕")
}

App 特质将对象的主方法作为程序入口，this.args 包含命令行传入的参数。这种写法比显式定义 main 方法更简洁，尤其适合小型程序或脚本。

需要注意的是，继承 App 的对象内部代码在 Scala 2.11 及以上版本中会被编译器包装成 main 方法。对于需要更精细控制的场景（如需要返回特定退出码），仍建议使用传统的 main 方法定义。

8. 实际项目中的单例对象组织

在真实项目中，单例对象通常按照功能职责进行组织。以下是一个典型的项目结构示例：

src/main/scala/
├── util/
│   ├── JsonParser.scala
│   └── Validator.scala
├── model/
│   └── User.scala
├── service/
│   └── Database.scala
└── Main.scala

每个单例对象承担明确的职责。工具类放在 util 包中，服务类放在 service 包中，领域模型可能包含伴生类和工厂对象。这种组织方式让代码结构清晰，便于团队协作和后期维护。

// util/JsonParser.scala
package util

import scala.util.parsing.json._

object JsonParser {
  def parseMap(json: String): Option[Map[String, Any]] = {
    JSON.parseFull(json).map(_.asInstanceOf[Map[String, Any]])
  }
}

// Main.scala
import util.JsonParser

object Main extends App {
  val json = """{"name": "Alice", "age": 30}"""
  val data = JsonParser.parseMap(json)
  data.foreach(println)
}

9. 注意事项与最佳实践

使用单例对象时需要牢记几个关键点。首先，单例对象的生命周期与应用程序相同，这意味着它持有的资源在整个运行期间都存在。确保在不再需要时适当释放资源（如数据库连接池）。

其次，并发访问需要同步保护。如果多个线程同时读写单例对象的可变状态，必须使用适当的同步机制。Scala 推荐使用不可变数据和 Future、Actor 等并发模型来避免共享状态的竞争。

object SafeCounter {
  import scala.collection.mutable
  private val counts = mutable.Map[String, Int]().withDefaultValue(0)

  def increment(key: String): Int = counts.synchronized {
    val newValue = counts(key) + 1
    counts(key) = newValue
    newValue
  }

  def get(key: String): Int = counts.synchronized(counts(key))
}

最后，避免在单例对象中放置过多的全局状态。过度使用单例会导致模块间耦合度增高，测试难度增大。将状态限制在必要的范围内，保持对象的职责单一。