首页 > 代码库 > 特质trait

特质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调用导致的方法调用可以在调用发生的地方明确决定。而对于特质来说,方法调用是由类和被混入到类的特质的线性化决定的。

特质trait