Java中的逆变与协变 专题
结论先行:
PECS总结: 要从泛型类取数据时,用extends; 协变 要往泛型类写数据时,用super; 逆变 既要取又要写,就不用通配符(即extends与super都不用) 不变
List<?>是一个泛型,在没有赋值之前,表示它可以接受任何类型的集合赋值,赋值之后就不能往里面添加元素了。
List<?>称为通配符集合。它可以接受任何类型的集合引用赋值,不能添加任何元素,但可以remove或clear,并非immutable集合。
List<?>一般作为参数来接收外部的集合,或者返回一个不知道具体元素类型的集合。
List<T>最大的问题是只能放置一种类型,如果随意转换类型的话,就是“破窗理论”,泛型就失去了类型安全的意义。
如果需要放置多种受泛型约束的类型呢?
<? extends T>与<? super T>两种语法,但是两者的区别非常微妙。
简单来说,
<? extends T>是Get First,适用于,消费集合元素为主的场景; put功能受限
<? super T>是Put First,适用于,生产集合元素为主的场景; get功能受限
<? extends T>可以赋值给任何T及T子类的集合,上界为T,取出来的类型带有泛型限制,向上强制转型为T。null可以表示任何类型,所以除null外,任何元素都不得添加进<? extends T>集合内。
<? super T>可以赋值给任何T及T的父类集合,下界为T。在生活中,投票选举类似于<? super T>操作。选举代表时,你只能往里投票,取数据时,根本不知道是谁票,相当于泛型丢失。
看下面一段代码
Number num = new Integer(1); ArrayList<Number> list = new ArrayList<Integer>(); //type mismatch List<? extends Number> list = new ArrayList<Number>(); list.add(new Integer(1)); //error list.add(new Float(1.2f)); //error
有人会纳闷,为什么Number
的对象可以由Integer
实例化,而ArrayList<Number>
的对象却不能由ArrayList<Integer>
实例化?list中的<? extends Number>
声明其元素是Number或Number的派生类,为什么不能addInteger
和Float
?为了解决这些问题,我们需要了解Java中的逆变和协变以及泛型中通配符用法。
1. 逆变与协变
在介绍逆变与协变之前,先引入Liskov替换原则
(Liskov Substitution Principle, LSP)。
Liskov替换原则
LSP由Barbara Liskov于1987年提出,其定义如下:
所有引用基类(父类)的地方必须能透明地使用其子类的对象。
LSP包含以下四层含义:
- 子类完全拥有父类的方法,且具体子类必须实现父类的抽象方法。
- 子类中可以增加自己的方法。
- 当子类覆盖或实现父类的方法时,方法的形参要比父类方法的更为宽松。
- 当子类覆盖或实现父类的方法时,方法的返回值要比父类更严格。
前面的两层含义比较好理解,后面的两层含义会在下文中详细解释。根据LSP,我们在实例化对象的时候,可以用其子类进行实例化,比如:
Number num = new Integer(1);
定义
逆变与协变用来描述类型转换(type transformation)后的继承关系,其定义:如果A、B表示类型,f(⋅)表示类型转换,≤表示继承关系(比如,A ≤ B表示A是由B派生出来的子类);
- f(⋅)是逆变(contravariant)的,当A ≤ B时有f(B)≤f(A)成立;
- f(⋅)是协变(covariant)的,当A ≤ B时有f(A)≤f(B)成立;
- f(⋅)是不变(invariant)的,当A ≤ B时上述两个式子均不成立,即f(A)与f(B)相互之间没有继承关系。
类型转换
接下来,我们来看看Java中常见类型转换的协变性、逆变性或不变性。
泛型
令f(A)=ArrayList<A>
,那么f(⋅)是逆变、协变还是不变的呢?如果是逆变,则ArrayList<Integer>
是ArrayList<Number>
的父类型;如果是协变,则ArrayList<Integer>
是ArrayList<Number>
的子类型;如果是不变,二者没有相互继承关系。开篇代码中用ArrayList<Integer>
实例化list
的对象错误,则说明泛型是不变的。
数组
令f(A)=[]A
,容易证明数组是协变的:
Number[] numbers = new Integer[3];
方法
方法的形参是协变的、返回值是逆变的:
通过与网友iamzhoug37的讨论,更新如下。
调用方法result = method(n)
;根据Liskov替换原则,传入形参n的类型应为method形参的子类型,即typeof(n)≤typeof(method's parameter)
;result应为method返回值的基类型,即typeof(methods's return)≤typeof(result)
:
static Number method(Number num) {
return 1;
}
Object result = method(new Integer(2)); //correct
Number result = method(new Object()); //error
Integer result = method(new Integer(2)); //error
在Java 1.4中,子类覆盖(override)父类方法时,形参与返回值的类型必须与父类保持一致:
class Super {
Number method(Number n) { ... }
}
class Sub extends Super {
@Override
Number method(Number n) { ... }
}
从Java 1.5开始,子类覆盖父类方法时允许协变返回更为具体的类型:
class Super {
Number method(Number n) { ... }
}
class Sub extends Super {
@Override
Integer method(Number n) { ... }
}
2. 泛型中的通配符
实现泛型的协变与逆变
Java中泛型是不变的,可有时需要实现逆变与协变,怎么办呢?这时,通配符?
派上了用场:
<? extends>
实现了泛型的协变,比如:
List<? extends Number> list = new ArrayList<Integer>();
<? super>
实现了泛型的逆变,比如:List<? super Number> list = new ArrayList<Object>();
extends与super
为什么(开篇代码中)List<? extends Number> list
在add Integer
和Float
会发生编译错误?首先,我们看看add的实现:
public interface List<E> extends Collection<E> { boolean add(E e); }
在调用add方法时,泛型E
自动变成了<? extends Number>
,其表示list所持有的类型为在Number与Number派生子类中的某一类型
,其中包含Integer类型却又不特指为Integer类型(Integer像个备胎一样!!!),故add Integer
时发生编译错误。
为了能调用add方法,可以用super
关键字实现:
List<? super Number> list = new ArrayList<Object>(); list.add(new Integer(1)); list.add(new Float(1.2f));
<? super Number>
表示list所持有的类型为在Number与Number的基类中的某一类型
,其中Integer与Float必定为这某一类型
的子类;所以add方法能被正确调用。从上面的例子可以看出,extends
确定了泛型的上界,而super
确定了泛型的下界。
PECS
现在问题来了:究竟什么时候用extends什么时候用super呢?《Effective Java》给出了答案:
PECS: producer-extends, consumer-super.
比如,一个简单的Stack API:
public class Stack<E>{ public Stack(); public void push(E e): public E pop(); public boolean isEmpty(); }
要实现pushAll(Iterable<E> src)
方法,将src的元素逐一入栈:
public void pushAll(Iterable<E> src){ for(E e : src) push(e) }
假设有一个实例化Stack<Number>
的对象stack,src有Iterable<Integer>
与 Iterable<Float>
;在调用pushAll方法时会发生type mismatch错误,因为Java中泛型是不可变的,Iterable<Integer>
与 Iterable<Float>
都不是Iterable<Number>
的子类型。因此,应改为
// Wildcard type for parameter that serves as an E producer public void pushAll(Iterable<? extends E> src) { for (E e : src) push(e); }
要实现popAll(Collection<E> dst)
方法,将Stack中的元素依次取出add到dst中,如果不用通配符实现:
// popAll method without wildcard type - deficient! public void popAll(Collection<E> dst) { while (!isEmpty()) dst.add(pop()); }
同样地,假设有一个实例化Stack<Number>
的对象stack,dst为Collection<Object>
;调用popAll方法是会发生type mismatch错误,因为Collection<Object>
不是Collection<Number>
的子类型。因而,应改为:
// Wildcard type for parameter that serves as an E consumer public void popAll(Collection<? super E> dst) { while (!isEmpty()) dst.add(pop()); }
在上述例子中,在调用pushAll方法时生产了E 实例(produces E instances),在调用popAll方法时dst消费了E 实例(consumes E instances)。Naftalin与Wadler将PECS称为Get and Put Principle。
java.util.Collections的copy方法(JDK1.7)完美地诠释了PECS:
public static <T> void copy(List<? super T> dest, List<? extends T> src) { int srcSize = src.size(); if (srcSize > dest.size()) throw new IndexOutOfBoundsException("Source does not fit in dest"); if (srcSize < COPY_THRESHOLD || (src instanceof RandomAccess && dest instanceof RandomAccess)) { for (int i=0; i<srcSize; i++) dest.set(i, src.get(i)); } else { ListIterator<? super T> di=dest.listIterator(); ListIterator<? extends T> si=src.listIterator(); for (int i=0; i<srcSize; i++) { di.next(); di.set(si.next()); } } }
PECS总结:
- 要从泛型类取数据时,用extends;
- 要往泛型类写数据时,用super;
- 既要取又要写,就不用通配符(即extends与super都不用)。
3. 参考资料
[1] meriton, Covariance, Invariance and Contravariance explained in plain English?.
[2] Bert F, Difference between <? super T> and <? extends T> in Java.
[3] Joshua Bloch, Effective Java.
http://www.cnblogs.com/en-heng/p/5041124.html
《Thinking in Java》中说很多原因促成了泛型的出现,最引人注目的一个原因就是为了创造容器类。这个要怎么来理解呢?我的理解是,可以抛开这个为了创造容器类这个,而是回到泛型的目的是限定某种类型上来。
所以我们现在能小结一下Object和T很重要的两点区别就是:
- Object范围非常广,而T从一开始就会限定这个类型(包括它可以限定类型为Object)。
- Object由于它是所有类的父类,所以会强制类型转换,而T从一开始在编码时(注意是在写代码时)就限定了某种具体类型,所以它不用强制类型转换。(之所以要强调在写代码时是因为泛型在虚拟机中会被JVM擦除掉它的具体类型信息,这点可参考泛型,在这里不做引申)。
https://www.cnblogs.com/yulinfeng/p/6056038.html