两个泛型类
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类型声明协变(或不变),编译时符合要求;