8 scala的共生对象

1 单例对象

在编写 Java 程序时，我们经常会通过编写静态方法代码，去封装常用的 Utility 类。

在 Scala 中没有静态成员这一概念，所以，如果我们要定义静态属性或方法，就需要使用 Scala 的单例对象 object。Scala 的对象跟 Javascript 中定义一个对象，概念是差不多的。

下面定义一个球员对象，并在 main 函数打印球员对象的相关属性：

/**
 * 球员对象
 */
object FootballPlayerObject {
  /**
   * 姓名
   */
  var NAME: String = "Mohamed Salah"
  /**
   * 年纪
   */
  var AGE: Int = 31
  /**
   * 所在俱乐部
   */
  var CLUB: String = "Liverpool"

  /**
   * 定义入口 main 函数，打印球员对象相关属性
   * @param args
   */
  def main(args: Array[String]): Unit = {
    System.out.println(FootballPlayerObject.NAME)
    System.out.println(FootballPlayerObject.AGE)
    System.out.println(FootballPlayerObject.CLUB)
  }
}

2 工具类案例

我们可以利用单例对象实现工具类，例如，下面实现了一个简易的 DateUtils

import org.joda.time.format.DateTimeFormat

/**
 * 日期时间工具类
 */
object DateUtils {
  val TIME_FORMAT = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss")

  /**
   * 判断一个时间是否在另一个时间之前
   *
   * @param time1 第一个时间
   * @param time2 第二个时间
   * @return 判断结果
   */
  def before(time1: String, time2: String): Boolean = {
    TIME_FORMAT.parseDateTime(time1).isBefore(TIME_FORMAT.parseDateTime(time2))
  }

  /**
   * 判断一个时间是否在另一个时间之后
   *
   * @param time1 第一个时间
   * @param time2 第二个时间
   * @return 判断结果
   */
  def after(time1: String, time2: String): Boolean = {
    TIME_FORMAT.parseDateTime(time1).isAfter(TIME_FORMAT.parseDateTime(time2))
  }

  /**
   * 计算时间差值（单位为秒）
   *
   * @param time1 时间1
   * @param time2 时间2
   * @return 差值
   */
  def minus(time1: String, time2: String): Int = {
    ((TIME_FORMAT.parseDateTime(time1).getMillis - TIME_FORMAT.parseDateTime(time2).getMillis) / 1000).toInt
  }

  def main(args: Array[String]): Unit = {
    println(DateUtils.before("2023-01-01 00:00:00", "2024-01-01 00:00:00"))
    println(DateUtils.after("2023-01-01 00:00:00", "2024-01-01 00:00:00"))
    println(DateUtils.minus("2024-01-01 00:00:00", "2023-01-01 00:00:00"))
  }
}

运行后，控制台打印：

true
false
31536000

3 伴生对象

如果想一个类，既需要静态成员，又需要实例成员，在 Scala 中可以使用伴生对象（companion object）来实现。

3.1 伴生对象的定义

伴生对象有以下特点：

(1) 伴生对象 和 类 必须要在同一个 class 文件中。

(2) 伴生对象名字要和类名字一致。

(3) 伴生类 和 伴生对象可以互相访问彼此的 private 属性。

/**
 * 球员信息类
 */
class PlayerInfo(private var playerName: String, var age: Int, var club: String) {
  def hello(): String = {
    s"Hey buddy, I am ${this.playerName} of ${this.club}, ${this.age} years old!"
  }
}

/**
 * PlayerInfo 类的共生对象
 */
object PlayerInfo {
  /**
   * 定义球员梦想
   */
  private var dream: String = "The dream of %s is achieving World Cup"

  /**
   * 打印球员梦想
   */
  def myDream(playerName: String): String = {
    String.format(this.dream, playerName)
  }

  /**
   * main 方法
   * @param args
   */
  def main(args: Array[String]): Unit = {
    // 定义球员信息对象
    val player: PlayerInfo = new PlayerInfo("Erling Haaland", 23, "Manchester City F.C.")
    println(player.hello())

    // 执行共生对象的 myDream 方法
    // 可以访问共生类的私有 playerName
    println(this.myDream(player.playerName))
  }
}

3.2 apply 及 unapply 方法

在 Scala 中，apply 和 unapply 是两个特殊的方法，它们通常与伴生对象一起使用，并且在模式匹配、构造对象等方面发挥着重要作用。

3.2.1 apply 方法

apply 方法通常用于对象的构造。当你调用类似 ClassName(args) 的代码时，实际上是调用了类的伴生对象的 apply 方法。这使得你可以像调用函数一样构造对象，而不需要显式地使用 new 关键字。

例如，我们在定义一个列表时，并不需要使用 new: val list = List(1, 2, 3)，下面为球员信息类的共生对象定义了 apply 方法：

/**
 * 球员信息类
 */
class PlayerInfo(private var playerName: String, var age: Int, var club: String) {
  def hello(): String = {
    s"Hey buddy, I am ${this.playerName} of ${this.club}, ${this.age} years old!"
  }
}

/**
 * PlayerInfo 类的共生对象
 */
object PlayerInfo {
  /**
   * 定义球员梦想
   */
  private var dream: String = "The dream of %s is achieving World Cup"

  /**
   * 打印球员梦想
   */
  def myDream(playerName: String): String = {
    String.format(this.dream, playerName)
  }

  /**
   * 定义 apply 方法，新建一个 PlayerInfo 对象
   *
   * @param playerName 球员名称
   * @param age 年龄
   * @return {@link PlayerInfo} 对象
   */
  def apply(playerName: String, age: Int): PlayerInfo = new PlayerInfo(playerName, age, "Manchester City F.C.")

  /**
   * main 方法
   * @param args
   */
  def main(args: Array[String]): Unit = {
    // 定义球员信息对象，有了 apply 方法后，不再需要 new 关键字
    val player: PlayerInfo = PlayerInfo("Erling Haaland", 23)
    println(player.hello())

    // 执行共生对象的 myDream 方法
    // 可以访问共生类的私有 playerName
    println(this.myDream(player.playerName))
  }
}

3.2.2 unapply 方法

unapply 方法通常用于模式匹配。它是 Extractor 模式的一部分，允许你从对象中提取部分信息，并将其与模式进行匹配。

例如：

/**
 * 球员信息类
 */
class PlayerInfo(private var playerName: String, var age: Int, var club: String) {
  def hello(): String = {
    s"Hey buddy, I am ${this.playerName} of ${this.club}, ${this.age} years old!"
  }
}

/**
 * PlayerInfo 类的共生对象
 */
object PlayerInfo {
  /**
   * 定义 apply 方法，新建一个 PlayerInfo 对象
   *
   * @param playerName 球员名称
   * @param age 年龄
   * @return {@link PlayerInfo} 对象
   */
  def apply(playerName: String, age: Int): PlayerInfo = new PlayerInfo(playerName, age, "Manchester City F.C.")

  /**
   * 定义 unapply，作为提取器，提取球员 姓名，年龄，俱乐部
   * @param playerInfo 球员信息对象
   * @return
   */
  def unapply(playerInfo: PlayerInfo): Option[(String, Int, String)] = Some(playerInfo.playerName, playerInfo.age, playerInfo.club)

  /**
   * main 方法
   * @param args
   */
  def main(args: Array[String]): Unit = {
    // 定义球员信息对象，有了 apply 方法后，不再需要 new 关键字
    val player: PlayerInfo = PlayerInfo("Erling Haaland", 23)
    player match {
      case PlayerInfo(name, age, club) => println(s"name: ${name}, age: ${age}, club: ${club}")
      case _ => println("Not matched")
    }
  }
}

在上面的代码中，unapply 方法从 PlayerInfo 对象中提取了名字、年龄和俱乐部，并将它们作为元组返回。在 match 表达式中，case PlayerInfo(name, age, club) 部分使用了模式匹配，它调用了 PlayerInfo 伴生对象的 unapply 方法来提取 PlayerInfo 对象的信息，并与模式中的名字、年龄和俱乐部进行匹配。