Scala伴生类和伴生对象

单例对象与类同名时，这个单例对象被称为这个类的伴生对象，而这个类被称为这个单例对象的伴生类。伴生类和伴生对象要在同一个源文件中定义，伴生对象和伴生类能够互相访问其私有成员。不与伴生类同名的单例对象称为孤立对象。

看看例子：

import scala.collection.mutable.Map

class ChecksumAccumulator {
  private var sum = 0
  def add(b: Byte) {
    sum += b
  }
  def checksum(): Int = ~(sum & 0xFF) + 1
}

object ChecksumAccumulator {
  private val cache = Map[String, Int]()
  def calculate(s: String): Int =
    if (cache.contains(s))
    cache(s)
  else {
      val acc = new ChecksumAccumulator
      for (c <- s)
        acc.add(c.toByte)
      val cs = acc.checksum()
      cache += (s -> cs)
      println("s:"+s+" cs:"+cs)
      cs
    }

  def main(args: Array[String]) {
    println("Java 1:"+calculate("Java"))
    println("Java 2:"+calculate("Java"))
    println("Scala :"+calculate("Scala"))
  }
}

　　

ChecksumAccumulator单例对象有一个方法，calculate，用来计算所带的String参数中字符的校验和。它还有一个私有字段，cache，一个缓存以前计算过的校验和的可变映射。2方法的第一行，“if (cache.contains(s))”，检查缓存，看看是否传递进来的字串已经做为键存在于映射当中。若是是，就仅仅返回映射的值，“cache(s)”。不然，执行else子句，计算校验和。else子句的第一行定义了一个叫acc的val并用新建的ChecksumAccumulator实例初始化它。下一行是个for表达式，对传入字串的每一个字符循环一次，并在其上调用toByte把字符转换成Byte，而后传递给acc所指的ChecksumAccumulator实例的add方法。完成了for表达式后，下一行的方法在acc上调用checksum，得到传入字串的校验和，并存入叫作cs的val。下一行，“cache += (s -> cs)”，传入的字串键映射到整数的校验和值，并把这个键-值对加入cache映射。方法的最后一个表达式，“cs”，保证了校验和为此方法的结果。

这里打印的结果是：

s:Java cs:-130
Java 1:-130
Java 2:-130
s:Scala cs:-228
Scala :-228

　　

问题来了，ChecksumAccumulator单例对象是不能new的，可是在代码中出现了val acc = new ChecksumAccumulator，这不是矛盾吗？其实否则，这里new的实际上是ChecksumAccumulator单例对象的伴生类，即ChecksumAccumulator类，而伴生类和伴生对象能够互相访问对方的私有成员，因此acc能够访问ChecksumAccumulator单例对象的cache变量。同理，那么第一次测试“Java”字符串的时候，acc实例执行了checksum()方法，接下来并把这个数据存到cache这个val中。在第二次测试“Java”字符串的时候，程序是直接从cache变量中获取到了数据，并返回。

这里也能够看出类和单例对象的一个差异是，单例对象是在第一次访问的时候初始化，不能够new，不能带参数，而类能够new，能够带参数。每一个单例对象都被做为由一个静态变量指向的虚构类：synthetic class的一个实例来实现，所以它们与Java静态类有着相同的初始化语法。

参考：《Scala编程》