特质trait

特质（trait）是scala里代码服用的基础单元。特质封装了方法和字段的定义，并可以通过“混入”到类中重用它们。与类的继承时每个类都只能继承唯一的超类不同，类可以混入任意多个特质。特质的定义除了使用关键字trait之外，与类定义无异，如代码1-1

代码1-1

trait Bird {
  def fly = println("鸟飞翔")
  def singing
}

 这个特质名为Fish，它没有声明超类，因此和类一样，有个默认的超类AnyRef。它定义了一个具体方法fly，也定义了一个抽象方法singing，等待被混入的类实现。一旦特质被定义了，就可以使用extends或with关键字，把它混入到类中，scala的混入特质并不是继承它们，将在本文的后面说明。

模拟一个场景，一个机器人继承了人类，人会说话，而机器人想要继续继承鱼的游泳、和鸟的飞翔和唱歌，需要用到特质，如代码1-2，Rebot类最先开始继承Person类，接着混入Fish特质和Bird特质，因此，机器人除了能工作，还能模拟鸟飞翔

代码1-2

scala> class Person {
  def say = println("人说话")
}

trait Fish {
  def swim = println("鱼游泳")
}

trait Bird {
  def fly = println("鸟飞翔")
  def singing
}

class Rebot extends Person with Fish with Bird {
  def work = println("机器人工作")
  def singing = println("机器人唱歌")
}
defined class Person
defined trait Fish
defined trait Bird
defined class Rebot

scala> val rebot = new Rebot()
rebot: Rebot = Rebot@3e44f2a5

scala> rebot.work
机器人工作

scala> rebot.fly
鸟飞翔

scala> rebot.singing
机器人唱歌

scala> val fish: Fish = rebot
fish: Fish = Rebot@3e44f2a5

scala> fish.swim
鱼游泳

 另外，因为Rebot这个类混入了Fish特质，所以可以用Fish的变量去接收Rebot对象，特质有点类似Java的抽象类，可以声明抽象方法和具体方法，但是Java的一个类只能继承一个抽象类，而scala一个类却可以混入多个特质，另外，特质不能带有任何类参数。代码1-3是合法的，而代码1-4则会报错

代码1-3

class Cat(color: String, age: Int)

 代码1-4

trait Cat(color: String, age: Int)

 如果想在特质里加入参数时，可如代码1-5这样做

代码1-5

scala> trait Cat {
  val color: String
  val age: Int
  def cry = println("小猫喵喵叫")
  def printColor = println("小猫的颜色是" + color)
  def printAge = println("小猫的年龄是" + age + "岁")
}
defined trait Cat

scala> val cat = new {
      val color = "白色"
      val age = 1
    } with Cat
cat: Cat = $anon$1@6bea52d4

scala> cat.printColor
小猫的颜色是白色

scala> cat.printAge
小猫的年龄是1岁

scala> cat.cry
小猫喵喵叫

 

Ordered特质

对象的比较是程序里常见的操作，比方定义一个有理数对象，用户可能调用<或者>=来判断两个对象之间的大小关系，如果没有Ordered特质之前，我们一般会像代码1-6这样做，Rational类是有理数类，类参数n代表分子，类参数d代表分母，私有成员g是n和d的最大公约数，我们会定义操作符来判断两个有理数对象的大小关系

代码1-6

scala> class Rational(n: Int, d: Int) {
  require(d != 0)
  private val g = gcd(n, d)
  val number = n / g
  val denom = d / g
  override def toString = number + "/" + denom
  private def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
  def <(that: Rational) = number * that.denom < that.number * denom
  def >(that: Rational) = that < this
  def ==(that: Rational) = (number == that.number && denom == that.denom)
  def <=(that: Rational) = this < that || this == that
  def >=(that: Rational) = this > that || this == that
}
defined class Rational

scala> val x = new Rational(1, 2)
x: Rational = 1/2

scala> val y = new Rational(1, 3)
y: Rational = 1/3

scala> x > y
res11: Boolean = true

 通过定义符号，我们可以比较对象间的大小关系，但scala专门提供了一个特质解决这样的问题，这个特质就是Ordered，Ordered特质让你仅仅只实现一个方法compare，使你的类可以使用>、<、>=、<=全套的比较方法，如代码1-7

代码1-7

scala> class Rational(n: Int, d: Int) extends Ordered[Rational] {
  require(d != 0)
  private val g = gcd(n, d)
  val number = n / g
  val denom = d / g
  override def toString = number + "/" + denom
  private def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b)
  def compare(that: Rational) = number * that.denom - that.number * denom
}
defined class Rational

scala> val a = new Rational(1, 3)
a: Rational = 1/3

scala> val b = new Rational(1, 5)
b: Rational = 1/5

scala> a > b
res12: Boolean = true

scala> val c = new Rational(1, 2)
c: Rational = 1/2

scala> val d = new Rational(2, 5)
d: Rational = 2/5

scala> c < d
res13: Boolean = false

scala> val e = new Rational(1, 3)
e: Rational = 1/3

scala> val f = new Rational(1, 5)
f: Rational = 1/5

scala> e >= f
res14: Boolean = true

 compare主要返回两个有理数对象做计算最后的结果，如果结果大于0则代表前一个对象大于后一个对象，如果结果小于0则代表前一个对象小于后一个对象，如果结果等于0代表两个对象相等

 

特质用来做可堆叠的改变

举个例子，思考一下对一个整数队列堆叠改动。队列有两种操作：put，把整数放入队列，和get，从队列取出整数，队列是先进先出的，因此get应该依整数进入队列时的顺序把它们取出来。

假设有一个类实现了这样的队列，你可以定义特质执行如下的改动：

• Doubling：把所有放入到队列的数字加倍。
• Incrementing：把所有放入到队列的数字增值
• Filtering：从队列中过滤掉负数

这三种特质代表了改动，因为它们改变了原始队列的行为而并非定义了全新的队列。这三种同样也是可堆叠的。

代码1-8为抽象的IntQueue类，put方法把整数添加到队列中，get方法返回并移除开头的整数，length返回队列的长度

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

 代码1-9的BasicIntQueue类是抽象类IntQueue的实现

代码1-9

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

代码1-10是运行时的样子：

 代码1-10

scala> val queue = new BasicIntQueue
queue: BasicIntQueue = BasicIntQueue@4fdfa676

scala> queue.put(-1)

scala> queue.put(2)

scala> queue.put(3)

scala> queue.length()
res3: Int = 3

scala> queue.get()
res4: Int = -1

scala> queue.get()
res5: Int = 2

scala> queue.get()
res6: Int = 3

 现在用特质改变它的行为，代码1-11展示了过滤掉负数，Filtering做了两件事情，第一件是它定义了超类IntQueue，这个定义意味着它只能混入扩展了IntQueue，因此可以把Filtering混入到BasicIntQueue，第二件事情是特质在声明为抽象的方法中有一个super的调用。这种调用对于普通的类来说是非法的，执行时必然失败。然而对于特质来说，则能调用成功。因为特质的super调用是动态绑定的。特质Filtering的super调用将直到被混入另一个特质或类之后，有了具体的方法定义时才工作。

这种安排对于实现可堆叠改动的特质来说是常常要用到的，为了告诉编译器你的目的，你必须在这种方法打上abstract override的标志。这种标识符的组合仅在特质成员的定义中被认可，在类中不行，它意味着特质碧玺混入某个具有期待方法的具体定义的类中。

代码1-11

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

 代码1-12中，queue变量只是简单地指明了一个类并混入一个特质，可以用这样的形式来替代命名类，联系代码1-11和代码1-12，我们将-1、2、3依次放入队列，但最后返回的队列长度只有2，因为-1被过滤掉了

代码1-12

scala> val queue = new BasicIntQueue with Filtering
queue: BasicIntQueue with Filtering = $anon$1@59221b97

scala> queue.put(-1)

scala> queue.put(2)

scala> queue.put(3)

scala> queue.length()
res3: Int = 2

scala> queue.get()
res4: Int = 2

scala> queue.get()
res5: Int = 3

 我们再加入两个特质，如代码1-13

代码1-13

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)
}

 代码1-14，我们可以看到，queue最长的长度为3，然而我们却放入了4个整数，两个负数两个正数，并且返回的数跟我们原先放入的数不同，越靠近右侧的特质越先起作用。Incrementing最先调用，对所有放入的数加1，接着就是Filtering，我们放入的-10+1后为-9，依旧小于0，所有我们放入的整数只有-1、2、3能到达Doubling，在到达Doubling，3个数经过前两个特质的转化后，变为0、3、4，经过Doubling后，每个数乘以2，为0、6、8，最后放入队列的就是0、6、8。

代码1-14

scala> val queue = new BasicIntQueue with Doubling with Filtering with Incrementing
queue: BasicIntQueue with Doubling with Filtering with Incrementing = $anon$1@131fcb6f

scala> queue.put(-10)

scala> queue.put(-1)

scala> queue.put(2)

scala> queue.put(3)

scala> queue.length()
res10: Int = 3

scala> queue.get()
res11: Int = 0

scala> queue.get()
res12: Int = 6

scala> queue.get()
res13: Int = 8

 特质是一种继承多个类似于类的结构的方式，但是它与许多语言中的多重继承有很重要的差别。其中的一个尤为重要：super的解释。对于多重继承来说，super调用导致的方法调用可以在调用发生的地方明确决定。而对于特质来说，方法调用是由类和被混入到类的特质的线性化决定的。