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)

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