Java 我可以将以下代码转换为使用泛型吗？

我正在将一个应用程序转换为使用Java 1.5，并找到了以下方法：

  /**
   * Compare two Comparables, treat nulls as -infinity.
   * @param o1
   * @param o2
   * @return -1 if o1<o2, 0 if o1==o2, 1 if o1>o2
   */
  protected static int nullCompare(Comparable o1, Comparable o2) {
    if (o1 == null) {
      if (o2 == null) {
        return 0;
      } else {
        return -1;
      }
    } else if (o2 == null) {
      return 1;
    } else {
      return o1.compareTo(o2);
    }
  }

理想情况下，我想让该方法采用两个相同类型的可比数据，是否可以转换，如何转换

我认为下面的方法可以奏效：

protected static <T extends Comparable> int nullCompare(T o1, T o2) {

将其更改为：

protected static <T extends Comparable<T>> int nullCompare(T o1, T o2) {

protectedstatic int nullCompare（to1，to2）{

您需要它，因为Comparable本身就是一个泛型类型。

这里有一个奇怪的情况：

static class A {
    ...
}

static class B extends A implements Comparable<A> {
    public int compareTo(A o) {
        return ...;
    }
}

静态A类{
...
}
静态类B扩展了A{
公共整数比较（AO）{
返回。。。；
}
}

幸运的是，像上面这样的代码很少见，但是nullCompare（）将不支持Bs的比较，除非声明Compariable可能适用于T或其任何超类：

---

protectedstatic我不确定泛化此方法是否有意义。目前，该方法适用于任何类型的可比较对象；如果泛化它，则必须实现它（使用完全相同的代码）多次。有时可以比较两个没有共同祖先的对象，任何通用版本都不允许这样做

通过添加泛型，您不会在代码中添加任何安全性；调用compareTo时会出现任何安全性问题。我的建议是简单地取消警告。它不会真正警告您任何有用的内容。
无法编辑，因此我必须发布我的答案

您需要声明嵌套类型参数，因为Comparable是泛型的

protected static <T extends Comparable<? super T>> int nullCompare(T o1, T o2) {

protectedstatic为了使它更通用，您甚至可以允许它用于两种不同的类型。=p

  /**
   * Compare two Comparables, treat nulls as -infinity.
   * @param o1
   * @param o2
   * @return -1 if o1&lt;o2, 0 if o1==o2, 1 if o1&gt;o2
   */
  protected static <T> int nullCompare(Comparable<? super T> o1, T o2) {
    if (o1 == null) {
      if (o2 == null) {
        return 0;
      } else {
        return -1;
      }
    } else if (o2 == null) {
      return 1;
    } else {
      return o1.compareTo(o2);
    }
  }

/**
*比较两个可比较项，将空值视为-无穷大。
*@param o1
*@param o2
*@return-1如果o1o2，0如果o1==o2，1如果o1o2
*/
受保护的静态整型空比较（ComparableArgh！我不敢相信我是如此接近你确定t extends Comparable是对的吗？似乎t extends Comparable更正确？@cletus:
t extends Comparable
是正确的。如果
Foo
对象在你尝试排序时可以将自身与
Bar
对象进行比较，那就没用了。
protected static <T extends Comparable<? super T>> int nullCompare(T o1, T o2) {

public static <T extends Comparable<? super T>> void sort(List<T> list) {

  /**
   * Compare two Comparables, treat nulls as -infinity.
   * @param o1
   * @param o2
   * @return -1 if o1&lt;o2, 0 if o1==o2, 1 if o1&gt;o2
   */
  protected static <T> int nullCompare(Comparable<? super T> o1, T o2) {
    if (o1 == null) {
      if (o2 == null) {
        return 0;
      } else {
        return -1;
      }
    } else if (o2 == null) {
      return 1;
    } else {
      return o1.compareTo(o2);
    }
  }