Scala之旅（TOUR OF SCALA）——通过混合组成类（CLASS COMPOSITION WITH MIXINS）

混合就是被用来组合成类的特征。

abstract class A {
  val message: String
}
class B extends A {
  val message = "I'm an instance of class B"
}
trait C extends A {
  def loudMessage = message.toUpperCase()
}
class D extends B with C

val d = new D
println(d.message)  // I'm an instance of class B
println(d.loudMessage)  // I'M AN INSTANCE OF CLASS B

类 D 有一个父类 B 和一个混合 C。类只能有一个父类但是可以有很多混合（分别使用关键字 extends 和 with）。混合和父类可能有相同的父类。

现在，让我们看一个使用抽象类更有趣的例子：

abstract class AbsIterator {
  type T
  def hasNext: Boolean
  def next(): T
}

上面的例子中的类有一个抽象的类型 T 和标准的迭代器方法。

下一步，我们将实现一个具体的类（所有的抽象成员 T，hasNext 和 next 都会被实现）：

class StringIterator(s: String) extends AbsIterator {
  type T = Char
  private var i = 0
  def hasNext = i < s.length
  def next() = {
    val ch = s charAt i
    i += 1
    ch
  }
}

实现类 StringIterator 需要一个字符串参数用来迭代字符。

现在，让我们创建一个特征也继承 AbsIterator。

trait RichIterator extends AbsIterator {
  def foreach(f: T => Unit): Unit = while (hasNext) f(next())
}

因为 RichIterator 是特征，所以不需要实现抽象类 AbsIterator 中的方法。

现在，我们将 StringIterator 类和 RichIterator 特征的功能组合成一个简单的类中。

object StringIteratorTest extends App {
  class RichStringIter extends StringIterator("Scala") with RichIterator
  val richStringIter = new RichStringIter
  richStringIter foreach println
}