混合就是被用来组合成类的特征。
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
}
新的类 RichStringIter
父类为 StringIterator
还混合了 RichIterator
特征。
这是我们使用简单的继承不能实现这种程度的复杂功能。