【Scala】特质与特质的线性化

特质

Scala里相当于Java接口的是Trait(特征)。实际上它比接口还功能强大。与接口不同的是，它还可以定义属性和方法的实现。Scala中特征被用于服务于单一目的功能模块的模块化中。通过混合这种特征（模块）群来实现各种应用程序的功能要求，Scala也是按照这个构想来设计的。

特质的构造顺序

特质也可以有构造器，由字段的初始化和其他特质体中的语句构成。这些语句在任何混入该特质的对象在构造时都会被执行。
构造器的执行顺序：

调用超类的构造器；

特质构造器在超类构造器之后、类构造器之前执行；
特质由左到右被构造；
每个特质当中，父特质先被构造；
如果多个特质共有一个父特质，父特质不会被重复构造
所有特质被构造完毕，子类被构造。

构造器的顺序是类的线性化的反向。线性化是描述某个类型的所有超类型的一种技术规格。

用作可堆叠改变的特质

特质的一个主要用法是把瘦接口（有较少的方法）转变成胖接口（有较多的方法）。
其第二个主要用法是为类提供可堆叠的改变。

考虑一个整数队列的例子。队列有两种操作：put，把整数放入队列；get，从尾部取出整数。

import scala.collection.mutable.ArrayBuffer

abstract class IntQueue {
    def get(): Int
    def put(x: Int)
}

class BasicIntQueue extends IntQueue {
    private val buf = new ArrayBuffer[Int]
    def get() = buf.remove(0)
    def put(x: Int) = { buf += x }
}

假设定义特质执行如下改动：

Doubling：把所有放入队列的数字加倍

Incrementing：把所有放入队列的数字增加
Filtering：从队列中过滤掉负整数

这三种特质代表了改动，因为它们改变了原始队列类的行为而并非定义了全新的队列类。这三种特质是可堆叠的，你可以选择它们混入类中，获得所需改动的全新的类。

//在特质中重写抽象方法

trait Doubling extends IntQueue {
    abstract override def put(x: Int) { super.put(2*x) }
}

trait Incrementing extends IntQueue {
    abstract override def put(x: Int) { super.put(x+1) }
}

trait Filtering extends IntQueue {
    abstract override def put(x: Int){
        if(x >= 0) super.put(x)
    }
}

解释：上面的代码定义了超类IntQueue，这个定义意味着该特质只能混入扩展IntQueue的类中。
在特质中声明抽象方法中有super调用，在特质里super调用时动态绑定的；而在类中，由于继承的抽象类，super调用时非法的。这里必须使用abstract override标识符，它意味着特质必须被混入某个具有期待方法的具体定义的类中，这种定义仅在特质定义中使用。

演示：

scala> val queue = new BasicIntQueue with Doubling
queue: BasicIntQueue with Doubling = $anon$1@1d3eff4

scala> queue.put(10)

scala> queue.get()
res10: Int = 20

val queue = new BasicIntQueue with Doubling with Incrementing
queue: BasicIntQueue with Doubling with Incrementing = $anon$1@19de304

scala> queue.put(-1)

scala> queue.put(2)

scala> queue.put(3)

scala> queue.get
res3: Int = 0

scala> queue.get
res4: Int = 6

scala> queue.get
res5: Int = 8

混入的顺序很重要，越靠近右侧的特质越先起作用。当你调用带混入的类的方法时，最右侧特质的方法首先被调用。如果那个方法调用了super，它调用其左侧特质的方法，以此类推。上面的例子里，Incrementing的put首先被调用，然后Doubing的put第二个被调用。

特质的线性化与多重集成

特质是一种继承多个类似于类的结构的方式，但是它与多重继承有很重要的区别。其中一个尤为重要：super的解释。
对于多重继承来说，super调用导致的方法调用可以在调用发生的地方明确决定；对于特质来说，方法调用是由类和混入到类的特质的线性化(linearization)所决定的。这种差别使得上面的特质的堆叠成为可能。

在多重继承的语言中，调用相同的方法，编译规则会决定哪个超类最终胜出，而调用该超类的指定方法。
而在Scala中，当你使用new实例化一个类的时候，Scala把这个类和所有它继承的类还有他的特质以线性的次序放在一起。然后，当你在其中的一个类中调用super，被调用的方法就是方法链的下一节。除了最后一个调用super之外的方法，其净结果就是可堆叠的行为。

线性化细节

Scala 的线性化的主要属性可以用下面的例子演示：假设你有一个类 Cat，继承自超类 Animal 以及两个特质 Furry 和 FourLegged。 FourLegged 又扩展了另一个特质 HasLegs：

class Animal
trait Furry extends Animal
trait HasLegs extends Animal
trait FourLegged extends HasLegs
class Cat extends Animal with Furry with FourLegged

类 Cat 的继承层级和线性化次序展示在下图。继承次序使用传统的 UML 标注指明：白色箭头表明继承，箭头指向超类型。黑色箭头说明线性化次序，箭头指向 super 调用解决的方向。

当这些类和特质中的任何一个通过super调用了方法，那么被调用的实现将是它线性化的右侧的第一个实现。

参考资料

Scala学习——特质

转载请注明作者Jason Ding及其出处
GitCafe博客主页(http://jasonding1354.gitcafe.io/)
Github博客主页(http://jasonding1354.github.io/)
CSDN博客(http://blog.csdn.net/jasonding1354)
主页(http://www.jianshu.com/users/2bd9b48f6ea8/latest_articles)
Google搜索jasonding1354进入我的博客主页