协变与逆变 Covariance & Contravariance

Covariance 协变

父类型相较于子类型变得更加具体
返回值类型：不变或变得更具体
示例如下：

class T {
	Object a() { … }
}
class S extends T {
	@Override 
	String a() { … } 
}

异常的类型：不变或变得更具体

Contravariance 逆变（反协变）

父类型相较于子类型变得更加具体，但与协变相反
参数类型：不变，或相反的变化即越来越抽象
示例如下：

class T {
	void c( String s ) { … }
}
class S extends T {
	@Override 
	void c( Object s ) { … } 
}

Java中遇到这种情况会当作overload，并报错提示

常见例子

数组——协变

Java中数组是协变的，对T[]数组，可以保存类型T及其子类型的数据，但保存的多个数据只能是单一类型的
示例如下：

	Number[] numbers = new Number[2];
	numbers[0] = new Integer(10);
	numbers[1] = new Double(3.14);

但如果为以下程序：

	Integer[] myInts = {1,2,3,4};
	Number[] myNumber = myInts;
	myNumber[0] = 3.14;

在运行时则会出现错误，因为数组已被实例化为整数类型

泛型

Type erasure 类型擦除

类型参数在编译后被丢弃，在运行时不可用；擦除时类型变量会被擦除，替换为限定类型，如果没有限定类型则替换为Object类型
例：

public class Node<T> {
	private T data;
	private Node<T> next;
	public Node(T data, Node<T> next) {
		this.data = data;
		this.next = next;
	}
	public T getData() {
		return data;
	}
}

编译经过类型擦除后：

public class Node {
	private Object data;
	private Node next;
	public Node(Object data, Node next) {
		this.data = data;
		this.next = next;
	}
	public Object getData() { 
		return data;
	}
}

另：若泛型类型继承多个父类或接口，则编译后只继承第一个父类或接口

public class Interval<T extends Comparable & Serializable> implements Serializable {
	private T lower;
	private T upper;
	...
	public Interval(T first, T second) {
		if (first.compareTo(second) <= 0) {
				lower = first;
				upper = second;
			}
		else {
			lower = second;
			upper = first;
		} 
	}
}

public class Interval implements Serializable
{
	private Comparable lower;
	private Comparable upper;
	. . .
	public Interval(Comparable first, Comparable second) { 
	. . .
	}
}

无限定通配符？

如： List<?>
无限定通配符适用于以下两种情况：
方法实现不依赖于参数类型，即不调用其中的方法；或者方法实现只依赖于Object 类中的方法功能

public static void printList(List<Object> list) {
	for (Object elem : list)
	System.out.println(elem + " ");
	System.out.println();
}

期望打印出各种类型的内容，但是由于泛型不协变，只能打印List<Object>，为了实现泛型的printList方法，使用无限定通配符？进行如下修改：

public static void printList(List<?> list) {
	for (Object elem: list)
	System.out.print(elem + " ");
	System.out.println();
}
List<Integer> in = Arrays.asList(1, 2, 3);
List<String> str = Arrays.asList("one", "two", "three");
printList(in);
printList(str);

Lower Bounded Wildcards: <? super A> 下限通配符

Upper Bounded Wildcards: <? extends A> 上限通配符

例子：
List<Number>is a subtype of List<?>
List<Number>is a subtype of List<? extends Object>
List<Object>is a subtype of List<? super String>