<? extends E> 和<? super E>的使用
<? extends E>的使用
Item 26
这是堆栈的公有API：
public class Stack<E>{
public Stack();
public void push(E e);
public E pop();
public boolean isEmpty();
public void pushAll(Iterable<E> src);
}
在使用方法pushAll时，添加src，其中的数据类型要跟当前的Stack完全相同，这样才可以使用。比如，Stack<Number>，那么src的类型就只能是Iterable<Number>，不能是Iterable<Integer>。因为，Iterable<Number>与Iterable<Integer>并不是同一个类型。
那么，如果要实现一种效果，可以添加的类型是Stack中元素类型的子类型，而不一定使用完全相同的类型。
可以通过有限制的通配符来实现：
public class Stack<E>{
public Stack();
public void push(E e);
public E pop();
public boolean isEmpty();
public void pushAll(Iterable<? extends E> src);
}
------------------------------------------------------------------------
<? super E>的使用
public class Stack<E>{
public Stack();
public void push(E e);
public E pop();
public boolean isEmpty();
public void pushAll(Iterable<? extends E> src);
public void popAll(Collection<E> dst);
}
要实现一个功能，将堆栈中的元素弹出来，保存到一个容器中。也就是实现popAll这个API。使用这个API是有要求的，那就是容器的类型要完全跟当前的Stack的类型一致。那么，假设，我们想堆栈中的元素可以存放在容器Collection<Object>中，那么，该如何重新定义popAll方法？
使用super关键字。
public class Stack<E>{
public Stack();
public void push(E e);
public E pop();
public boolean isEmpty();
public void pushAll(Iterable<? extends E> src);
public void popAll(Collection<? super E> dst);
}
修改后的popAll方法，可以保存堆栈弹出的元素的容器类型是这样的，容器类型是Stack元素类型的父类。
好处：使用了上述的通配符，会提高API的灵活性，让它可以接受更多的类型。
pushAll 是数据的生产者；对生产者的进参数使用 <? extends E>，可以接受更多的类型，而不是只是E这种类型，可以接受E及其子类的类型。
popAll是数据的消费者；对消费者出参数使用<? super E>，可以让堆栈的数据保存在多种类型的容器中，而不只是保存在Collection<E>。它可以保存在类型是E的父类的容器中。
-----------------------------------------------------------------------------------------------------------------------------------------------
类型推导失效的情况：
调用方法Set<Number> numbers = Union.union(integers, doubles);Java编译器在进行类型推导时，不能确定类型参数究竟是使用哪个(Integer,Double)，在这种情况下要显示指定类型参数。Set<Number> numbers = Union.<Number> union(integers, doubles);
public class Union {
public static <E> Set<E> union(Set<? extends E> s1, Set<? extends E> s2) {
Set<E> result = new HashSet<E>(s1);
result.addAll(s2);
return result;
}
// Simple program to exercise flexible generic method
public static void main(String[] args) {
Set<Integer> integers = new HashSet<Integer>();
integers.add(1);
integers.add(3);
integers.add(5);
Set<Double> doubles = new HashSet<Double>();
doubles.add(2.0);
doubles.add(4.0);
doubles.add(6.0);
// Won‘t compile; see page 137
// Set<Number> numbers = union(integers, doubles);
// Explicit type parameter is necessary here
Set<Number> numbers = Union.<Number> union(integers, doubles);
System. out.println(numbers);
}
}
------------------------------------------------------------------------------
使用有限制的通配符，让比较操作不只是限定在一种具体类型上：
版本一：
class Parent implements Comparable<Parent> {
@Override
public int compareTo(Parent o) {
// TODO Auto-generated method stub
//实现比较留空
return 0;
}
}
class ChildOne extends Parent {
}
class ChildTwo extends Parent {
}
public class RecursiveTypeBound {
// Returns the maximum value in a list - uses recursive type bound
public static <T extends Comparable<T>> T max(List<T> list) {
Iterator<T> i = list.iterator();
T result = i.next();
while (i.hasNext()) {
T t = i.next();
if (t.compareTo(result) > 0)
result = t;
}
return result;
}
public static void main(String[] args) {
List<String> argList = Arrays. asList(args);
System.out.println( max(argList));
List<ChildOne> oneList = new ArrayList<ChildOne>();
// max(oneList);
// Bound mismatch: The generic method max(List<T>) of type RecursiveTypeBound is
// not applicable for
// the arguments (List<ChildOne>). The inferred type ChildOne is not
// a valid substitute for the bounded parameter <T extends Comparable<T>>
}
}
分析：<T extends Comparable<T>> ，该类型参数有如下限定：针对可以与自身进行比较的每个类型T。
但是，使用ChildOne类型的容器oneList,作为参数调用max方法，执行是失败的。
失败的原因是，ChildOne实例可以与其它继承了Parent的类的实例进行比较，比如，ChildTwo实例。这样就违反了约束条件：只能与自身进行比较(Comparable<T>)。
版本二：使用有限制的通配符来解决版本一的问题
class Parent implements Comparable<Parent> {
@Override
public int compareTo(Parent o) {
// TODO Auto-generated method stub
return 0;
}
}
class ChildOne extends Parent {
}
class ChildTwo extends Parent {
}
public class RecursiveTypeBound {
public static <T extends Comparable<? super T>> T max(List<? extends T> list) {
Iterator<? extends T> i = list.iterator();
T result = i.next();
while (i.hasNext()) {
T t = i.next();
if (t.compareTo(result) > 0)
result = t;
}
return result;
}
public static void main(String[] args) {
List<String> argList = Arrays. asList(args);
System.out.println( max(argList));
List<ChildOne> oneList = new ArrayList<ChildOne>();
max(oneList);
}
}
分析：新定义的泛型方法，首先，它使用的类型参数是：可以与自身进行比较的类型；可以与与该类型本身是类型兼容的类型相比较的类型。这是将Comparable<T>转换为Comparable<? super T>。
比如，ChildOne可以与ChildOne进行比较；ChildOne可以与ChildTwo进行比较。
从版本一转换为版本二，List<T>转换为List<? extends T>，转换的规则是，按照生产者消费者规则，List是生产者，使用<? extends T>。含义变化为，max不再接受单一一种类型，它可以接受某一类的类型。
比如:
List<Parent> oneList = new ArrayList<Parent>();
oneList.add(new ChildOne());
oneList.add(new ChildTwo());
oneList.add(new Parent());
max(oneList);
由接受一种具体的类型，变为接受一个种类的类型。
Comparable<T>是消费者，它是使用参数List的数据来进行操作的。转换它的时候，使用Comparable<? super T>。
----------------------------------------------------------------------------------------------------------------------------------
类型参数和通配符
List<E>和List<?>
很多方法可以同时使用这两种方式来实现。
比如，交换列表中的元素：
版本1:
public class SwapE {
public static <E> void swap(List<E> list, int i, int j) {
list.set(i, list.set(j, list.get(i)));
}
public static void main(String[] args) {
// Swap the first and last argument and print the resulting list
List<String> argList = Arrays. asList(args);
swap(argList, 0, argList.size() - 1);
System. out.println(argList);
}
}
版本2:
public class Swap {
public static void swap(List<?> list, int i, int j) {
swapHelper(list, i, j);
//list.set(i, list.set(j, list.get(i)));，因为只能往List<?>放null。
}
// Private helper method for wildcard capture
private static <E> void swapHelper(List<E> list, int i, int j) {
list.set(i, list.set(j, list.get(i)));
}
public static void main(String[] args) {
// Swap the first and last argument and print the resulting list
List<String> argList = Arrays. asList(args);
swap(argList, 0, argList.size() - 1);
System. out .println(argList);
}
}