scala 学习笔记(05) OOP（中）灵活的trait

trait -- 不仅仅只是接口！

接上回继续，scala是一个非常有想法的语言，从接口的设计上就可以发现它的与众不同。scala中与java的接口最接近的概念是trait，见下面的代码：

package yjmyzz


object App {

  def main(args: Array[String]) {
    val bird = Bird("pigeon")
    bird.fly
    println(bird.isInstanceOf[Bird]) //true
    println(bird.isInstanceOf[Flyable]) //true
    println(bird.toString) //this is a Bird:pigeon
    bird.test //hello
  }
}

/**
 * 定义一个"接口"
 */
trait Flyable {

  /**
   * 定义接口方法
   */
  def fly;


  /**
   * 接口中也有可以方法的实现（是不是惊呆了！）
   * @return
   */
  def test = {
    println("hello")
  }
}


class Bird(var name: String) extends Flyable {
  /**
   * 实现接口中的方法
   */
  def fly: Unit = {
    println("I am a " + name + ", and I can fly~")
  }

  override def toString = {
    "this is a Bird:" + name
  }
}

object Bird {
  def apply(name: String) = {
    new Bird(name)
  }

}

从上面的代码中，可以看出trait与java中interface的异同，相同的是如果把trait单纯当接口来用，trait中只需要定义方法签名即可，然后由"子类"来实现。不同的是，scala中的trait里也可以有方法实现！而且实现接口时，关键字不是implements而是extends(当然，还可能是with，后面还会提到)，这说明scala中trait并不仅仅只是接口，它也是一种特殊的类。

trait的mixin：

trait还有一个神奇的特性，可以在运行时，动态与其它类合体！见下面的代码：

package yjmyzz


object App {

  def main(args: Array[String]) {
    val duck = new Bird("duck") with Swim
    println(duck.isInstanceOf[Flyable]) //true
    println(duck.isInstanceOf[Swim]) //true 注意这里：表示此时Bird也是一个Swim实例
    duck.fly //I am a duck, and I can fly~
    duck.swim //I can swim! 注：是不是很有意思，绝对的动态晚绑定！
  }
}

/**
 * 定义一个"接口"
 */
trait Flyable {

  /**
   * 定义接口方法
   */
  def fly;


  /**
   * 接口中也有可以方法的实现（是不是惊呆了！）
   * @return
   */
  def test = {
    println("hello")
  }
}


/**
 * 再来一个"接口"
 */
trait Swim {
  def swim = {
    println("I can swim!")
  }
}


class Bird(var name: String) extends Flyable {

  /**
   * 实现接口中的方法
   */
  def fly: Unit = {
    println("I am a " + name + ", and I can fly~")
  }

  override def toString = {
    "this is a Bird:" + name
  }
}

我们又新增了一个trait：Swim，然后注意第7行，通过with Swim，硬是把跟Swim毫不相关的Bird实例跟它搅在一起了，然后实例duck就获得了Swim的能力! 这种场景下，trait就不应该理解为接口，而应该认为它是一种特性，是一种可以动态赋予其它实例的超能力！（这也是为什么关键字不叫interface，而是叫trait的原因吧）

trait与java中的接口还有一个明显的区别，trait可以继承自类，java中的interface可是不允许继承自class的！ 见下面的代码示例：

package yjmyzz

/**
 * 动物基类
 */
class Animal {}

/**
 * 会飞的动物（"接口"继承类）
 */
trait FlyAnimal extends Animal {
  def fly;
}

/**
 * 即会飞又会游泳的动物("接口"继承"接口")
 */
trait SwimAndFlyAnimal extends FlyAnimal {
  def swim;
}

/**
 * 会说话（注：这个接口是完全独立的，不继承自任何其它类或trait）
 */
trait Talk {
  def talk;
}

/**
 * 鸟（继承类，又实现"接口",实际上是多重继承）
 */
class Bird(var birdName: String) extends Animal with FlyAnimal {
  override def fly: Unit = {
    println(birdName + "能飞！")
  }
}

/**
 * 被继承的class[Animal]与trait[Talk]相互之间也可以没半毛钱关系
 */
class AlienAnimal extends Animal with Talk {
  override def talk: Unit = println("外星动物很厉害的啦，它们会说话！")
}

/**
 * 类也可以直接继承自trait
 */
class TalkThing extends Talk {
  override def talk: Unit = println("我也不知道我是啥，反正我会说话！")
}

object ScalaApp {

  def main(args: Array[String]) {

    var eagle = new Bird("老鹰")
    eagle.fly

    println

    var swan = new Bird("天鹅") with SwimAndFlyAnimal {
      override def swim: Unit = println("天鹅还能游泳！")
    }
    swan.fly
    swan.swim

    println

    var sparrow = new Bird("麻雀") with Talk {
      override def talk: Unit = println {
        "麻雀'说话'，就是叽叽喳喳的叫！"
      }
    }
    sparrow.fly
    sparrow.talk

    println

    var alienAnimal = new AlienAnimal
    alienAnimal.talk

    println

    var talkThing = new TalkThing
    talkThing.talk


  }

}

运行结果：

老鹰能飞！

天鹅能飞！
天鹅还能游泳！

麻雀能飞！
麻雀'说话'，就是叽叽喳喳的叫！

外星动物很厉害的啦，它们会说话！

我也不知道我是啥，反正我会说话！

关于trait，小结一下：

1、trait"类似"(注：仅仅只是类似)java中的接口，可以只定义方法签名，交由子类去实现

2、trait中也可以有具体的方法实现

3、trait可以继承自trait，也可以继承自class

4、class也可以直接继承自trait

5、trailt可以在运行时，通过with关键，动态混入class实例