scala中的variance

定义：
两个泛型类
class A[type_a]
class B[type_b]
如果 type_a是type_b 的 父类 那么A也是B的父类，那么就称之为 convariance(协变)；
如果 type_a是type_b 的 父类 A是B的子类，那么就称之为 contravariance(逆变)；

如果一个类型支持协变或逆变，则称这个类型为variance(翻译为可变的或变型)，否则称为invariant(不可变的)。
在Java里，泛型类型都是invariant，比如 List<String> 并不是 List<Object> 的子类型。不过Java支持使用点变型(use-site variance)，所谓“使用点“，也就是在声明变量时:

List<? extends Object> list = new ArrayList<String>();
//scala中的写法
scala> val a : List[_ <: Any] = List[String]("A")

有一点要注意：父类是variance，如果子类继承父类，需要声明为协变，不然默认不是协变类型。
例如
class A[+type_a] 是convariance

声明 class B extends class A 
那么 class B 默认是 不可变的（invariance）

class A[T+]
class B[T] extends A[T]
class C
class D extends C
//这种写法是错误的因为B[C] 不是B[D]的父类
val b:B[C] = new B[D]

class A[+T]
class B[+T] extends A[+T]
class C
class D extends C
//这种写法是正确的
val b:B[C] = new B[D]

里氏替换原则中说，任何基类可以出现的地方，子类一定可以出现。

class A[+T]{
def fun(x:A){.....}
}

我们来分析下上面的代码
例如

class A(String){def fun(x:String)}
class A(Object){def fun(x:Object)}

可以看到 A(Object) 是 A(String) 的父类 那么问题来了，里氏替换原则说fun方法中子类能替换父类，但是如果Object是一个具体的对象，并不是String类型，则就会报错。因为父类做的事情，子类不能完全胜任，只能部分满足，是无法代替父类型的。

怎么解决呢

class A[-T]{
def fun(x:T){.....}
}

如此定义之后 A(Object) 是 A(String) 的子类，这样String 就可以用 object替换了。

同理我们再定义一个类

class A[+T]{
def fun:T{.....}
}

我们来分析下上面的代码
例如

class A(String){def fun:String=...}
class A(Object){def fun:Object=...}

可以看到 A(Object) 是 A(String) 的父类,里氏替换原则说fun方法中子类能替换父类.子类方法得到的结果比父类更“具象”一些，也就是说子类方法的处理能力更强一些。
综上所述
方法中的参数类型声明时必须符合逆变（或不变），以让子类方法可以接收更大的范围的参数(处理能力增强)；而不能声明为协变，子类方法可接收的范围是父类中参数类型的子集(处理能力减弱)。
方法返回值的位置称为协变点(covariant position)。同理，A类型声明协变(或不变)，编译时符合要求；