Java Collections.max方法类型参数声明签名<;T<;?超级T>&燃气轮机;解释

Java Collections.max方法类型参数声明签名<;T<;?超级T>&燃气轮机;解释,java,generics,wildcard,Java,Generics,Wildcard,在Naftalin和wadler在第3章比较和界限中的Java泛型中,它以Collections.max方法为例 <T extends Comparable<? super T>> T max(Collection<? extends T> coll) 你引用错了这本书。该声明是关于水果可比的案例。在这种情况下,Orange将不是的有效候选对象,因为Orange没有实现可比的。因此,您不能将列表作为列表传递,除非您不明白什么?为什么从列表中查找max是不合法

在Naftalin和wadler在第3章比较和界限中的Java泛型中,它以Collections.max方法为例

<T extends Comparable<? super T>> T max(Collection<? extends T> coll)

你引用错了这本书。该声明是关于
水果可比
的案例。在这种情况下,
Orange
将不是
的有效候选对象,因为
Orange
没有实现
可比的
。因此,您不能将
列表
作为
列表
传递,除非
您不明白什么?为什么从列表中查找max是不合法的,这意味着如果指定了t的类型定义,它将面临什么问题,因为我认为这是我的困惑所在。我无法确定“如果没有超级通配符,查找列表的最大值将是非法的,即使查找列表的最大值是允许的”这句话是关于第一个示例的,其中
<T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
abstract class Fruit {
    protected String name;
    protected int size;
    protected Fruit(String name, int size) {
        this.name = name; this.size = size;
    }
    public boolean equals(Object o) {
        if (o instanceof Fruit) {
        Fruit that = (Fruit)o;
        return this.name.equals(that.name) && this.size == that.size;
        } else return false;
    }
    public int hashCode() {
        return name.hashCode()*29 + size;
    }
    protected int compareTo(Fruit that) {
        return this.size < that.size ? -1 :
        this.size == that.size ? 0 : 1 ;
    }

}
class Apple extends Fruit implements Comparable<Apple> {
    public Apple(int size) {
         super("Apple", size); 
    }
public int compareTo(Apple a) { 
    return super.compareTo(a); 
    }
}
class Orange extends Fruit implements Comparable<Orange> {
    public Orange(int size) { 
        super("Orange", size); 
    }
public int compareTo(Orange o) {
         return super.compareTo(o);
     }
}
class Test {
public static void main(String[] args) {
    Apple a1 = new Apple(1); 
    Apple a2 = new Apple(2);
    Orange o3 = new Orange(3); 
    Orange o4 = new Orange(4);
    List<Apple> apples = Arrays.asList(a1,a2);
    assert Collections.max(apples).equals(a2);
    List<Orange> oranges = Arrays.asList(o3,o4);
    assert Collections.max(oranges).equals(o4);
    List<Fruit> mixed = Arrays.<Fruit>asList(a1,o3);
    assert Collections.max(mixed).equals(o3); // compile-time error
    }
}
Orange extends Comparable<? super Orange>
Orange extends Comparable<Fruit> and Fruit super Orange