Scala基础（7）- 特质

特质是Scala中一个很重要的特性。

更灵活的接口

Scala的特质（trait）定义和class几乎相同，只是trait不能的构造不能包含参数。

  trait TraitClassA {
    def doSomething() {
       println("call A");
    }
}

  trait TraitClassB {
    def doSomething() {
        println("call B");
    }
}

在使用trait的时候，可以用extend或者with。with的方式成为混入（mixin）。用户可以with任意多个特质。这会让你想起接口（Interface）。

  class A extends B with TraitClassA with TraitClassB {
          ...
}

Trait可以看做是更灵活，更丰富的接口。和Java中接口不同的是，Trait可以包含成员和方法的实现。这样做的好处需要某个trait就拿来用，而不需要重复实现接口。trait和混入的类是正交的。

举例说明，在Java中，定义一个Rational类就需要重写多个比较的方法。

class Rational(n: Int, d: Int) {
          // ...
          def < (that: Rational) =
            this.numer * that.denom > that.numer * this.denom
          def > (that: Rational) = that < this
          def <= (that: Rational) = (this < that) || (this == that)
          def >= (that: Rational) = (this > that) || (this == that)
}

而如果使用trait，这些比较的方法就可以封装在Ordered这个特质中（注意到这里使用到了类型参数[Rational]）。以后所有需要实现比较特质的类，它只要实现compare方法。

class Rational(n: Int, d: Int) extends Ordered[Rational] {
    // ...
    def compare(that: Rational) =
      (this.numer * that.denom) - (that.numer * this.denom)
}

而在使用的时候，你还是可以使用>，<=这样的方法，因为它们已经在Ordered特质中得到了实现。

值得注意的是，Java8中也借鉴了类似的方式。现在你可以在Java的接口中定义默认的实现了。但是它的限制还是很多。对于Java8一些新特性和Scala的比较，今后会专门讲。

堆叠和线性化

在下面的例子里，我们定义了带时间戳的日志和截断过长的的日志，这两个特质。

// 带时间戳的日志
trait TimestampLogger extends Logged {
  override def log (msg: String) {
    super.log(new java.util.Date() + " " + msg)
  }
}
 
// 截断过长的的日志

trait ShortLogger extends Logged {
  val maxLength = 20
  override def log(msg: String) {
    super.log(
      if (msg.length <= maxLength) msg
      else msg.substring(0, maxLength - 3) + "...")
  }
}

我们的应用就可以混入这两个特质。

class myApp with TimestampLogger with ShortLogger

你也许觉得trait和C++中的多继承很像。但是它们有着根本的区别。在多继承的框架里，你必须指定哪个super被调用（比如通过虚函数）。这样，在上面的例子中，只有一个log方法会调用。而trait恰恰可以堆叠多个特性，每个log都会被调用。这才符合多个特质的语义。

注意到混入是有顺序的，基本上可以认为是最右边的先调用。在更复杂的情景中，Scala使用了线性化的方式，将复杂的继承图映射到一条线上，以保障多个特质执行的顺序。

使用原则

什么时候使用特质呢？

• 不需要复用的，或者执行效率非常关键，考虑使用具体类。
• 会在多个不太相关的类中使用，考虑使用特质。
• 继承自Java的代码，或者希望Java client以后调用，使用抽象函数。
• 不太确定使用哪种方式，考虑先使用特质，以后再调整。

使用特质的一个重要原则就是保持traits简短并且是正交的。不要把分离的功能混在一个trait里，考虑将最小的相关的意图放在一起。例如，想象一下你要做一些IO的操作：

trait IOer { 
    def write(bytes: Array[Byte]) 
    def read(n: Int): Array[Byte] 
}

分离两个行为：

trait Reader { def read(n: Int): Array[Byte] } 
trait Writer { def write(bytes: Array[Byte]) }

可以将它们以混入的方式实现一个

IOer : new Reader with Writer...

接口最小化促使更好的正交性和更清晰的模块化。