很多语言都对协变提供了语法支持,scala使用[+T]
表示协变,java可以用<? extend T>
间接表示协变。那么如何理解协变呢?针对泛型的场景,泛型类的继承性与类型参数的继承性保持一致即为协变。理解了协变之后问题又来了,协变可以在什么样的场景使用呢?
想象一下这样一个简单地场景
- 首先有一个基类
Fruit
- 两个水果
Apple
和Banana
都继承自Fruit
- 一个果盘
Plate
- 一个抽象的果盘的制造商
PlateFactory
- 两个水果分别有自己的果盘制造商
ApplePlateFactory
、BananaPlateFactory
ok,这样就可以了。有几点需要注意
- 果盘是一个泛型类,用来装各种水果。根据协变的语义,苹果是水果的子类,那么苹果盘也是水果盘的子类。
- 果盘的制造商需要一个抽象,用来生产各类水果的果盘,也就是说制造商需要得到
Plate[Fruit]
。
代码的实现很简单
package lm.trm.scala
/**
* <h3>协变</h3>
* <p>
* 协变只是一种语法糖,有更好,没有也行。
* </p>
* Created by TerrorM on 2017/2/1.
*/
object Covariation {
def main(args: Array[String]): Unit = {
val plate1: Plate[Fruit] = ApplePlateFactory.getPlate
val plate2: Plate[Fruit] = BananaPlateFactory.getPlate
println(plate1.get) // Apple(I am an apple)
println(plate2.get) // Banana(I am a banana)
}
trait PlateFactory[T <: Fruit] {
def getPlate: Plate[Fruit]
}
class Fruit
case class Apple(name: String) extends Fruit
case class Banana(name: String) extends Fruit
class Plate[+T <: Fruit](val t: T) {
def get: T = t
}
object ApplePlateFactory extends PlateFactory[Apple] {
override def getPlate: Plate[Apple] = new Plate[Apple](Apple("I am an apple"))
}
object BananaPlateFactory extends PlateFactory[Banana] {
override def getPlate: Plate[Banana] = new Plate[Banana](Banana("I am a banana"))
}
}
简单地说明一下
我们用Plate[Fruit]
接收了Plate[Apple]
,这是因为果盘被定义为了Plate[+T]
。如果把+去掉,就会收到下面的错误
Expression of type Covariation.Plate[Covariation.Apple] dosen’t conform to expected type Covariation.Plate[Covariation.Fruit]
而scala会建议我们
Note: lm.trm.scala.Covariation.Apple <: lm.trm.scala.Covariation.Fruit, but class Plate is invariant in type T.
You may wish to define T as +T instead. (SLS 4.5)
值得注意的是
- 协变只是一种语法糖,可以让
Plate[Fruit]
接收Plate[Apple]
的实例,这使得代码看起来聚合度更高。如果不用协变的话,所有制造商都返回Plate[Fruit]
也不会有什么问题。 - 面向对象编程里返回值其实也暗含了协变的思想:具体制造商的返回值
Plate[Apple]
是抽象制造商的返回值Plate[Fruit]
的子类。换句话说:子类的返回值类型只能是基类返回值类型本身或是其派生类。 - java的泛型不能直接支持协变,可以通过通配符
?
实现;数组支持协变,即:Number[] arr = new Integer[10]
是合法的;scala的数组是不支持协变的。 - 协变不适合处理“消费(对元素进行处理,比如说
set
)”的场景,例如:arr[0] = 1.1
,编译可通过,运行时报异常:java.lang.ArrayStoreException: java.lang.Double
。因为语法糖是优化语法的使用,仅在编译期生效。对于Number[]
接收一个Double
元素天经地义呀,但是运行时就不一样了,因为arr
实际是一个Integer[]
。
换一种角度
如果不使用继承,可以用更抽象的方式:
object GenericPlateFactory {
def getPlate[T <: Fruit](implicit ct: ClassTag[T]): Plate[T] = {
val cls: Class[T] = ct.runtimeClass.asInstanceOf[Class[T]]
val constructor: Constructor[T] = cls.getDeclaredConstructor(classOf[String])
new Plate[T](constructor.newInstance("i am " + ct.runtimeClass.getSimpleName))
}
}
方法的调用就变成了:
val plate3: Plate[Fruit] = GenericPlateFactory.getPlate[Apple]
val plate4: Plate[Fruit] = GenericPlateFactory.getPlate[Banana]
println(plate3.get) // Apple(i am Apple)
println(plate4.get) // Banana(i am Banana)
泛型这种写法虽然看起来很臃肿,但是应该没有更简洁的方式了。