如何编写通用方法来查找最大元素并调用该方法？

当我试图解决运动问题时来自泛型教程问答 http://docs.oracle.com/javase/tutorial/java/generics/QandE/generics-answers.html我的答案略有不同

我的回答

public static <T extends Comparable<? super T>>
    T max(List<? extends T> list, int begin, int end) //Option1

public static <T extends Comparable<T>>
    T max(List<? extends T> list, int begin, int end) //Option2

从下面引用的答案

所以我的问题是

• 选项1：如果T extends Object & Comparable<? super T>被替换为T extends Comparable<? super T>. Isn't extends Object隐含的？

• 选项2：如果Comparable<? super T>被替换为Comparable<T>？如果是这样怎么办？

• Eclipse 代码完成创建局部变量List<? extends Comparable<? super Comparable<? super T>>> list;按 Ctrl+1max(list, 1, 10);这有点长。如何定义扩展的类（层次结构）Comparable<? super T>，创建列表并将实例添加到列表中并调用下面的方法？基本上我想知道如何调用max()添加类实例后A or B进入一个列表，其中class B extends A

编写一个通用方法来查找范围内的最大元素 列表的[开始、结束)。

Answer:

import java.util.*;

public final class Algorithm {
    public static <T extends Object & Comparable<? super T>>
        T max(List<? extends T> list, int begin, int end) {

        T maxElem = list.get(begin);

        for (++begin; begin < end; ++begin)
            if (maxElem.compareTo(list.get(begin)) < 0)
                maxElem = list.get(begin);
        return maxElem;
    }
}

如果有的话会有什么不同吗Comparable<? super T>被替换为Comparable<T>？如果是这样怎么办？

请记住可比较始终是消费者，即Comparable<T>消耗T实例，所以最好总是使用Comparable<? super T>代替Comparable<T>（引用-PECS）。如果您正在比较其超类实现了Comparable<SuperType>。考虑以下代码：

class Parent implements Comparable<Parent> {
    protected String name;

    @Override
    public int compareTo(Parent o) {
        return this.name.compareTo(o.name);
    }
}

class Child extends Parent {
    public Child(String name) {
        this.name = name;
    }
}

现在，如果您将类型参数指定为T extends Comparable<T>，您将无法调用该方法List<Child>, as Child不实施Comparable<Child> but Comparable<Parent>:

public static <T extends Comparable<T>> T max(List<? extends T> list, int begin, int end) {
    ...
}

public static void main(String[] args) {
    List<Child> list = new ArrayList<Child>();
    max(list, 0, 2);  // Error with current method. Child does not implement Comparable<Child>
}

因此类型参数界限应该是T extends Comparable<? super T>.

请注意，您无法更改您的Child类：

class Child extends Parent implements Comparable<Child>

因为在那种情况下，Child类将从同一泛型类型的不同实例化扩展而来，这是不允许的。

如果有的话会有什么不同吗T extends Object & Comparable<? super T>被替换为T extends Comparable<? super T>。 extends Object 不是隐式的吗？

Well, there is a difference between the two bounds. In the 1^st bound, the erasure of the type parameter is Object, whereas in the 2^nd bound, the erasure is Comparable.

所以，没有Object绑定后，您的代码将编译为：

public static Comparable max(List list, int begin, int end)

当您生成遗留的非通用代码时，可能会出现问题。有必要给予Object也作为上限以避免破坏字节码兼容性。您可以在此链接上阅读更多相关信息：Angelika Langer - 编程习语 http://www.angelikalanger.com/GenericsFAQ/FAQSections/ProgrammingIdioms.html#FAQ104