scala变性

标准动物库有一个函数满足了你的需求，但它的参数是Animal。在大多数情况下，如果你说“我需要一个，我有一个的子类”是可以的。但是，在函数参数这里是逆变的。如果你需要一个接受参数类型Bird的函数变量，但却将这个变量指向了接受参数类型为Chicken的函数，那么给它传入一个Duck时就会出错。然而，如果将该变量指向一个接受参数类型为Animal的函数就不会有这种问题：

scala> class Animal { val sound = "rustle" }
defined class Animal

scala> class Bird extends Animal { override val sound = "call" }
defined class Bird

scala> class Chicken extends Bird { override val sound = "cluck" }
defined class Chicken

scala> val getTweet: (Bird => String) = ((a: duck) => a.sound )
<console>:9: error: not found: type duck
       val getTweet: (Bird => String) = ((a: duck) => a.sound )
                                             ^
//这里duck不是Bird的超类，因此报错。
scala> val getTweet: (Bird => String) = ((a: Animal) => a.sound )
getTweet: Bird => String = <function1>
//这里发生了逆变
scala> 

函数的返回值类型是协变的。如果你需要一个返回Bird的函数，但指向的函数返回类型是Chicken，这当然是可以的。

scala> val hatch: (() => Bird) = (() => new Chicken )
hatch: () => Bird = <function0>

scala> 

边界

Scala允许你通过 边界 来限制多态变量。这些边界表达了子类型关系。

scala> def cacophony[T](things: Seq[T]) = things map (_.sound)
<console>:7: error: value sound is not a member of type parameter T
       def cacophony[T](things: Seq[T]) = things map (_.sound)
                                                        ^

scala> def biophony[T <: Animal](things: Seq[T]) = things map (_.sound)
biophony: [T <: Animal](things: Seq[T])Seq[java.lang.String]

scala> biophony(Seq(new Chicken, new Bird))
res5: Seq[java.lang.String] = List(cluck, call)

scala> val flock = List(new Bird, new Bird)
flock: List[Bird] = List(Bird@7e1ec70e, Bird@169ea8d2)

scala> new Chicken :: flock
res53: List[Bird] = List(Chicken@56fbda05, Bird@7e1ec70e, Bird@169ea8d2)
scala> new Animal :: flock
res59: List[Animal] = List(Animal@11f8d3a8, Bird@7e1ec70e, Bird@169ea8d2)注意返回类型是Animal。