引子:
爲了弄懂scala中協變和逆變這兩個概念,查閱了不少資料,但是還是要自己總結一下,會記得比較深刻。
那就從java和scala的對比說起吧。
java中:
如果你很理解java的泛型,就會知道:比如給定一個類B,和他的父類A。
那麼用多態, A a = new B 編譯器是允許的。
但是如果泛型B的集合直接賦給父類A的集合。List<A> aList = new ArrayList<B>();
舉個簡單的例子:
Object s = "abc";
List<Object> objects = new ArrayList<String>();
編譯不通過,編譯器提示:
Type mismatch: cannot convert from ArrayList<String> to List<Object>
scala中:
我們知道sting是AnyRef的子類。直接賦值是可以的。
如果是將string的集合賦值給AnyRef的集合,在scala中也是可以的。
scala> val s:AnyRef = "abc"
s: AnyRef = abc
scala> var objects : List[AnyRef] = List[String]("abc","123")
objects: List[AnyRef] = List(abc, 123)
原因就在於List其實是支持協變的。
上界和下界
Scala和Java類似,Java中, (? extends T), T稱爲上界,, 代表T和T的子類, (? supers T), T稱爲下界。
(1) U >: T
這是類型下界的定義,也就是U必須是類型T的父類(或本身,自己也可以認爲是自己的父類)。
(2) S <: T
這是類型上界的定義,也就是S必須是類型T的子類(或本身,自己也可以認爲是自己的子類)。
1、定義泛型類的上界
/* 下面的意思就是表示只要是Comparable就可以傳遞,下面是類上定義的泛型
*/
class GenericTest1[T <: Comparable[T]] {
def choose(one:T,two:T): T ={
//定義一個選擇的方法
if(one.compareTo(two) > 0) one else two
}
}
class Boy(val name:String,var age:Int) extends Comparable[Boy]{
override def compareTo(o: Boy): Int = {
this.age - o.age
}
}
object GenericTestOne{
def main(args: Array[String]): Unit = {
val gt = new GenericTest1[Boy]
val huangbo = new Boy("huangbo",60)
val xuzheng = new Boy("xuzheng",66)
val boy = gt.choose(huangbo,xuzheng)
println(boy.name)
}
}
2、定義泛型方法的上界
class GenericTest2{
//在方法上定義泛型
def choose[T <: Comparable[T]](one:T,two:T): T ={
if(one.compareTo(two) > 0) one else two
}
}
class Boy(val name:String,var age:Int) extends Comparable[Boy]{
override def compareTo(o: Boy): Int = {
this.age - o.age
}
}
object GenericTestTwo{
def main(args: Array[String]): Unit = {
val gt = new GenericTest2
val huangbo = new Boy("huangbo",60)
val xuzheng = new Boy("xuzheng",66)
val boy = gt.choose(huangbo,xuzheng)
println(boy)
}
}
3、下界示例
class GranderFather
class Father extends GranderFather
class Son extends Father
class Tongxue
object Card{
def getIDCard[T >: Son](person:T): Unit ={
println("OK,交給你了")
}
def main(args: Array[String]): Unit = {
getIDCard(new Father)
getIDCard(new GranderFather)
getIDCard(new Son)
//getIDCard(new Tongxue)//報錯,所以註釋
}
}
協變和逆變
對於一個帶類型參數的類型,比如 C[T],在聲明Scala的泛型類型時,“+”表示協變,而“-”表示逆變。
協變
[+T], covariant (or “flexible”) in its type parameter T,類似Java中的(? extends T), 即可以用T和T的子類來替換T,里氏替換原則。
可以看到List的定義:
type List[+A] = scala.collection.immutable.List[A]
協變的符號是[+A],意味着支持泛型A的子類集合向A進行賦值。
不變
[T], invariant in its type parameter T
在scala可變集合中,MutableList是一個不變的類型。
定義:
class MutableList[A]
extends AbstractSeq[A]
......
我們還用相似的場景,將一個MutableList的string類型付給MutableList的AnyRef類型,這樣的賦值是不允許的。
編譯器會提示class MutableList is invariant in type A. 即在類型A中MutableList是不支持協變和逆變的。
scala> import scala.collection.mutable._
import scala.collection.mutable._
scala> val a : MutableList[AnyRef] = MutableList[String]("abc")
<console>:10: error: type mismatch;
found : scala.collection.mutable.MutableList[String]
required: scala.collection.mutable.MutableList[AnyRef]
Note: String <: AnyRef, but class MutableList is invariant in type A.
You may wish to investigate a wildcard type such as `_ <: AnyRef`. (SLS 3.2.10)
val a : MutableList[AnyRef] = MutableList[String]("abc")
^
逆變
[-T], contravariant, 類似(? supers T)
if T is a subtype of type S, this would imply that Queue[S] is a subtype of Queue[T]
只能用T的父類來替換T。是逆里氏替換原則。
在 scala.actors.OutputChannel 這個trait是一個逆變的類型。
trait OutputChannel[-Msg] {
......
對於OutputChannel[String], 支持的操作就是輸出一個string, 同樣OutputChannel[AnyRef]也一定可以支持輸出一個string, 因爲它支持輸出任意一個AnyRef(它要求的比OutputChannel[String]少) 。
但反過來就不行, OutputChannel[String]只能輸出String, 顯然不能替換OutputChannel[AnyRef]
總結:
協變
[+T], covariant (or “flexible”) in its type parameter T,類似Java中的(? extends T), 即可以用T和T的子類來替換T,里氏替換原則。
不變
不支持T的子類或者父類,只知支持T本身。
逆變
[-T], contravariant, 類似(? supers T) 只能用T的父類來替換T。是逆里氏替換原則。
上界:
只允許T的超類U來替換T。 [U >: T]
下界:
只允許T的子類U來替代T。 [U <: T]
參考: