scala学习手记34

trait的方法的延迟绑定就是先混入的trait的方法会后调用。这一点从上一节的实例中也可以看出来。

下面再来看一个类似的例子：

abstract class Writer {
  def write(message: String): String
}

trait UpperWriter extends Writer {
  abstract override def write(message: String): String = super.write(message.toUpperCase)
}


trait FilterWriter extends Writer {
  abstract override def write(message: String): String = super.write(message.replace('o', '-'))
}


trait StringWriter extends Writer {
  def write(message: String): String = message
}

val myWriter1 = new StringWriter with UpperWriter with FilterWriter

val myWriter2 = new StringWriter with FilterWriter with UpperWriter

println(myWriter1 write "Hello World!")

println(myWriter2 write "Hello World!")

在代码中定义了一个抽象类和三个trait。

其中抽象类Writer仅定义了一个抽象方法，并没有提供具体的实现。因此继承抽象类Writer的trait必须要实现write方法。

UpperWriter的write方法实现了将传入的英文字符转为大写；

FilterWriter的write方法实现了将小写的“o”替换为“-”；

StringWriter则只是将传入的字符串原样返回。

看一下上面的代码的执行结果：

验证了我们的说法：延迟绑定就是先混入的trait会后执行。

myWriter1的执行顺序：FilterWriter –> UpperWriter –> StringWriter；

myWriter2的执行顺序：UpperWriter –> FilterWriter –> StringWriter。

从trait的延迟绑定很容易会想到java的父类与子类的初始化顺序。又或者是java中的责任链模式。因此想想用java来实现这一点并不难：可以采用不同顺序的责任链，也可以是使用不同的继承顺序来实现。

再者，从这两节可以看出来scala中的trait和抽象类并无多大差别：

1. 都可以有普通方法和抽象方法；
2. 都可以有普通成员变量和抽象变量；
3. 抽象类能做的事情trait都能做。

那他们的差别在哪儿呢：

• trait可以多重混入，抽象类只能单继承；
• 抽象类可以定义构造函数；
• trait可以混入实例，抽象类不可以。

那什么时候用trait，什么时候用抽象类呢：

• 优先使用trait。一个类扩展多个trait是很方便的，但却只能扩展一个抽象类。
• 如果你需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而trait不行。例如，你不能说trait t(i: Int) {}，参数i是非法的。

参考文档：

https://twitter.github.io/scala_school/zh_cn/basics.html

http://stackoverflow.com/questions/1991042/what-is-the-advantage-of-using-abstract-classes-instead-of-traits

http://www.artima.com/pins1ed/traits.html#12.7

##############