[读书日志]从零开始学习Chisel 第六篇：Scala面向对象编程——特质（敏捷硬 ...

3.4特质

3.4.1什么是特质

特质使用trait开头，它与单例对象很像，两者都不能有输入参数，但单例对象是详细的，特质是抽象的。两者都不能用new实例化，类，单例对象，特质三者内部都可以包罗字段和方法，以及其他类，单例对象，特质的界说。
特质可以被其他类，单例对象和特质“混入”。混入在超类调用上采用线性化机制，在其他方面其实和继承是一样的。某个类混入一个特质后，会包罗特质的所有公有成员，可以通过override来重写特质的成员。Scala只允许继承自一个类，但是对特质的混入数目没有限定，因此用来替代多重继承的语法。要混入一个特质，可以使用关键字extend，已被占用后可以使用with混入其他特质。

1. scala> class A {
2.      | val a = "Class A"
3.      | }
4. // defined class A
6. scala> trait B {
7.      | val b = "Trait B"
8.      | }
9. // defined trait B
11. scala> trait C {
12.      | val c = "Trait C"
13.      | }
14. // defined trait C
16. scala> object D extends A with B with C
17. // defined object D
19. scala> D.a
20. val res7: String = Class A
22. scala> D.b
23. val res8: String = Trait B
25. scala> D.c
26. val res9: String = Trait C

复制代码

特质也界说了一个类型，可以指向混入该特质的对象。

1. scala> trait A
2. // defined trait A
4. scala> class B extends A
5. // defined class B
7. scala> val x: A = new B
8. val x: A = B@39159b14

复制代码

3.4.2特质的条理

特质也可以继承自其他类，或混入任意多个特质，对混入有一个限定条件，即要混入该特质的类/单例对象/特质，它的超类必须是待混入特质的超类，或是待混入特质的超类的子类。换句话说，一个特质假如想要“继承”（注意，这里的“继承”现实上是“混入”，只是为了理解特质用来替代多重继承的特质。）另一个特质，那么它只能继承比它层级更低的特质。

1. scala> class A
2. // defined class A
4. scala> class B extends A
5. // defined class B
7. scala> class C
8. // defined class C
10. scala> trait D extends A
11. // defined trait D
13. scala> trait E extends B
14. // defined trait E
16. scala> class Test1 extends D
17. // defined class Test1
19. scala> class Test2 extends A with D
20. // defined class Test2
22. scala> class Test3 extends B with D
23. // defined class Test3
25. scala> class Test4 extends C with D
26. -- Error: --------------------------------------------------------------------------------------------------------------
27. 1 |class Test4 extends C with D
28.   |                           ^
29.   |                           illegal trait inheritance: superclass C does not derive from trait
30. D's superclass A
31. 1 error found
33. scala> class Test5 extends A with E
34. -- Error: --------------------------------------------------------------------------------------------------------------
35. 1 |class Test5 extends A with E
36.   |                           ^
37.   |                           illegal trait inheritance: superclass A does not derive from trait
38. E's superclass B
39. 1 error found

复制代码

画图表示如下：

Test4继承自classC，它混入的特质是traitD，该特质的超类是classA，它不是classC的超类或超类的子类，因此无法混入；Test5继承自classA，它混入的traitE继承自classB，但classB是classA的子类，因此不能混入。假如把它们换一下顺序，使Test6继承classB而混入一个超类是classA的特质traitD，那么则可以运行。这个例子说明，一个类或特质的超类是哪个，是由extends关键字决定的。

1. scala> class Test6 extends B with D
2. // 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文件：

1. abstract class A {
2.   def m(s: String) : String
3. }
5. class X extends A {
6.   def m(s: String) = "X ->" + s
7. }
9. trait B extends A {
10.   abstract override def m(s: String) = super.m("B ->" + s)
11. }
13. trait C extends A {
14.   abstract override def m(s: String) = super.m("C ->" + s)
15. }
17. trait D extends A {
18.   abstract override def m(s: String) = super.m("D ->" + s)
19. }
21. trait E extends C {
22.   abstract override def m(s: String) = super.m("E ->" + s)
23. }
25. trait F extends C {
26.   abstract override def m(s: String) = super.m("F ->" + s)
27. }
29. class G extends X {
30.   override def m(s: String) = "G ->" + s
31. }
33. val x = new G with D with E with F with B
34. @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时立即混入特质，则相当于普通的方法重写，假如上一层超类是抽象类，立即引入会报错。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。