3.4特质
3.4.1什么是特质
特质使用trait开头，它与单例对象很像，两者都不能有输入参数，但单例对象是具体的，特质是抽象的。两者都不能用new实例化，类，单例对象，特质三者内部都可以包含字段和方法，以及其他类，单例对象，特质的定义。
特质可以被其他类，单例对象和特质“混入”。混入在超类调用上采用线性化机制，在其他方面其实和继承是一样的。某个类混入一个特质后，会包含特质的所有公有成员，可以通过override来重写特质的成员。Scala只允许继承自一个类，但是对特质的混入数量没有限制，因此用来替代多重继承的语法。要混入一个特质，可以使用关键字extend，已被占用后可以使用with混入其他特质。
scala> class A {
| val a = "Class A"
| }
// defined class A
scala> trait B {
| val b = "Trait B"
| }
// defined trait B
scala> trait C {
| val c = "Trait C"
| }
// defined trait C
scala> object D extends A with B with C
// defined object D
scala> D.a
val res7: String = Class A
scala> D.b
val res8: String = Trait B
scala> D.c
val res9: String = Trait C
特质也定义了一个类型，可以指向混入该特质的对象。
scala> trait A
// defined trait A
scala> class B extends A
// defined class B
scala> val x: A = new B
val x: A = B@39159b14
3.4.2特质的层次
特质也可以继承自其他类，或混入任意多个特质，对混入有一个限制条件，即要混入该特质的类/单例对象/特质，它的超类必须是待混入特质的超类，或是待混入特质的超类的子类。换句话说，一个特质如果想要“继承”（注意，这里的“继承”实际上是“混入”，只是为了理解特质用来替代多重继承的特质。）另一个特质，那么它只能继承比它层级更低的特质。
scala> class A
// defined class A
scala> class B extends A
// defined class B
scala> class C
// defined class C
scala> trait D extends A
// defined trait D
scala> trait E extends B
// defined trait E
scala> class Test1 extends D
// defined class Test1
scala> class Test2 extends A with D
// defined class Test2
scala> class Test3 extends B with D
// defined class Test3
scala> class Test4 extends C with D
-- Error: --------------------------------------------------------------------------------------------------------------
1 |class Test4 extends C with D
| ^
| illegal trait inheritance: superclass C does not derive from trait
D's superclass A
1 error found
scala> class Test5 extends A with E
-- Error: --------------------------------------------------------------------------------------------------------------
1 |class Test5 extends A with E
| ^
| illegal trait inheritance: superclass A does not derive from trait
E's superclass B
1 error found
画图表示如下：
Test4继承自classC，它混入的特质是traitD，该特质的超类是classA，它不是classC的超类或超类的子类，因此无法混入；Test5继承自classA，它混入的traitE继承自classB，但classB是classA的子类，因此不能混入。如果把它们换一下顺序，使Test6继承classB而混入一个超类是classA的特质traitD，那么则可以运行。这个例子说明，一个类或特质的超类是哪个，是由extends关键字决定的。
scala> class Test6 extends B with D
// defined class Test6
3.4.3混入特质的简便方法
如果要快速构建一个混入某些特质的实例，可以使用这个语法：
new Trait1 with Trait2 ... {definition}
这句话定义了一个匿名类，匿名类混入了这些特质。还可以在最前面加上一个想要继承的超类：
new SuperClass with Trait1 with Trait2 ... {definition}
3.4.4特质的线性化叠加计算
多重继承中一个很明显的问题是当子类调用超类的方法时，若多个超类都有该方法的不同实现，那么需要额外的语法确定具体调用哪个版本。Scala的特质采取一种线性化的规则来调用特质中的方法，在特质中，super调用是动态绑定的，按特质本身的定义，无法确定super调用的具体行为，直到特质混入某个类或别的特质，有了具体的超类方法，才能确定super的行为，这是实现线性化的基础。
若要通过混入特质来实现某个方法的线性叠加，有以下几个要求：
- 需要在特质中定义同名同参的方法，并加关键字组合
abstract override，这个关键词不是重写，只能用于特质中； - 该特质必须混入某个拥有该方法的具体定义的类中，这个类定义了该方法的最终行为；
- 需要混入特质进行线性化计算的类，定义时不能立即混入特质，这样做会让编译器认为这个类是在重写末尾那个特质的方法。应该先定义这个类的子类来混入特质，然后构造子类的对象，或者直接用3.4.3所述方法快速构造子类对象；
- 特质对该方法的定义必须出现
super.方法名(参数) - 方法的执行顺序遵循线性化计算公式，起点是公式从左往右第一个特质，外部传入的参数由起点接收，起点的
super.方法名(参数)会调用起点右边第一个特质的同名方法，并把起点的计算结果作为参数传递，以此类推。最后结果会回到最左边的类本身。 - 这个类实际上直接或间接重写或实现了基类的方法，如果定义中也出现了
super.方法名(参数)，则会调用它的上一层超类的实现版本。如果这个类没有重写，那就要有继承自超类的实现。
线性化计算公式：
- 最左边是类本身；
- 在类的右边写下定义时最后混入的那个特质，并接着往右按继承顺序写下该特质的所有超类和超特质；
- 继续往右写下倒数第二个混入的特质，以及其超类和超特质，直到写完所有特质；
- 所有重复项值保留最右边的那个，并在最右边加上
AnyRef和Any
现在我们编写这样的一个test.scala文件：
abstract class A {
def m(s: String) : String
}
class X extends A {
def m(s: String) = "X ->" + s
}
trait B extends A {
abstract override def m(s: String) = super.m("B ->" + s)
}
trait C extends A {
abstract override def m(s: String) = super.m("C ->" + s)
}
trait D extends A {
abstract override def m(s: String) = super.m("D ->" + s)
}
trait E extends C {
abstract override def m(s: String) = super.m("E ->" + s)
}
trait F extends C {
abstract override def m(s: String) = super.m("F ->" + s)
}
class G extends X {
override def m(s: String) = "G ->" + s
}
val x = new G with D with E with F with B
@main def test() = println(x.m("End"))
最终，需要混入特质进行线性化运算的类G在定义时没有立即混入特质，只是继承了classX，且通过new G with D with E with F with B构建了G的匿名子类的对象。类A是一个抽象类，类X实现了抽象方法m，类G重写了X的m，其余特质也用abstract override重写了m，这保证m最后会回到G。A的m返回类型“String”是必须的。
根据线性化计算公式，我们一步步进行计算。注意类X也就是这个类G继承的类不参与运算，最左边是类本身：G ->，在类的右边写下定义时最后混入的特质，然后往右按照继承顺序写下该特质所有的超类和超特质，全部写完后再写第二个混入的类，以此类推。因此第二个写下的是最后混入的特质B和它的超类：G -> B -> A接着写类F。以此类推，我们写出：
G -> B -> A -> F -> C -> A -> E -> C -> A -> D -> A
之后我们删除其中重复的部分：
G -> B -> F -> E -> C -> D -> A
之后补上AnyRef和Any：
G -> B -> F -> E -> C -> D -> A -> AnyRef -> Any
起点是B，传入“End”，B输出“B -> End”，之后再传给F，输出“F -> B -> End”，继续向右调用，最后到A时没有操作可以执行，转回G的m，最终得到运行结果是：
G ->D ->C ->E ->F ->B ->End
如果G的m也有super或没有重写，那么会调用X的m，导致最后最左边多一个X，如果在定义G时立即混入特质，则相当于普通的方法重写，如果上一层超类是抽象类，立即引入会报错。
