关于Java中的通用通配符，我有几个问题：
List<? extends T>和之间有什么区别List<? super T>？
什么是有界通配符，什么是无界通配符？
Answers:
在您的第一个问题中，<? extends T>并且<? super T>是有界通配符的示例。无限制的通配符看起来像<?>，并且基本上表示<? extends Object>。宽松地表示泛型可以是任何类型。有界通配符（<? extends T>或<? super T>）通过说必须扩展特定类型（<? extends T>称为上限）或必须是特定类型的祖先（<? super T>称为下限）来对类型进行限制。
<? super C>这意味着您的类型仅限C于类型层次结构中的上述内容。（对不起，我的回复太晚了。我想我们两年前没有评论通知吗？）
如果您具有类层次结构A，则B是A的子类，而C和D两者都是B的子类，如下所示
class A {}
class B extends A {}
class C extends B {}
class D extends B {}然后
List<? extends A> la;
la = new ArrayList<B>();
la = new ArrayList<C>();
la = new ArrayList<D>();
List<? super B> lb;
lb = new ArrayList<A>(); //fine
lb = new ArrayList<C>(); //will not compile
public void someMethod(List<? extends B> lb) {
B b = lb.get(0); // is fine
lb.add(new C()); //will not compile as we do not know the type of the list, only that it is bounded above by B
}
public void otherMethod(List<? super B> lb) {
B b = lb.get(0); // will not compile as we do not know whether the list is of type B, it may be a List<A> and only contain instances of A
lb.add(new B()); // is fine, as we know that it will be a super type of A
}有界通配符就像? extends BB是某种类型。也就是说，类型是未知的，但是可以在其上放置“绑定”。在这种情况下，它受到某个类的限制，该类是B的子类。
List<? super B>描述为List接受为B类的父类的类型？这就是为什么C和D无法编译hmm的原因？
乔什·布洛赫（Josh Bloch）也对何时使用super以及extends在此google io视频谈话中有很好的解释，他在其中提到了“ 生产者extends消费者”super助记符。
从演示幻灯片：
假设您要向其中添加批量方法
Stack<E>
void pushAll(Collection<? extends E> src);– src是电子制作人
void popAll(Collection<? super E> dst);– dst是电子消费者
有时您可能想限制允许传递给类型参数的类型的种类。例如，对数字进行操作的方法可能只希望接受Number或其子类的实例。这就是有界类型参数的用途。
Collection<? extends MyObject> 表示它可以接受与MyObject 有IS-关系的所有对象（即，是myObject类型的任何对象，或者我们可以说MyObject的任何子类的任何对象）或MyObject类的对象。
例如：
class MyObject {}
class YourObject extends MyObject{}
class OurObject extends MyObject{}然后，
Collection<? extends MyObject> myObject; 将仅接受MyObject或MyObject的子对象（即，任何类型OurObject或YourObject或MyObject的对象，但不接受MyObject的超类的任何对象）。
一般来说，
如果结构包含类型为form的
? extends E元素，则可以从结构中取出元素，但不能将元素放入结构中
List<Integer> ints = new ArrayList<Integer>();
ints.add(1);
ints.add(2);
List<? extends Number> nums = ints;
nums.add(3.14); // compile-time error
assert ints.toString().equals("[1, 2, 3.14]"); 要将元素放入结构中，我们需要另一种通配符Wildcards with super，
List<Object> objs = Arrays.<Object>asList(2, 3.14, "four");
List<Integer> ints = Arrays.asList(5, 6);
Collections.copy(objs, ints);
assert objs.toString().equals("[5, 6, four]");
public static <T> void copy(List<? super T> dst, List<? extends T> src) {
for (int i = 0; i < src.size(); i++) {
dst.set(i, src.get(i));
}
}