Scala的泛型,上界和下屆、協變和逆變

引子:

爲了弄懂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]

 

參考:

http://blog.csdn.net/oopsoom/article/details/24773239

https://www.cnblogs.com/qingyunzong/p/8877403.html>

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章