scala中协变(Covariation)的应用场景

很多语言都对协变提供了语法支持，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)

泛型这种写法虽然看起来很臃肿，但是应该没有更简洁的方式了。