Kann ich den folgenden Code verwenden Generika-Format konvertieren?

Question

Ich bin Umwandlung einer Anwendung Java 1.5 zu verwenden und haben die folgende Methode gefunden:

  /**
   * 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);
    }
  }

Im Idealfall würde Ich mag die Methode nimmt zwei Vergleichszahl des gleichen Typs machen, ist es möglich, dies zu konvertieren und wie?

Ich dachte, die folgend würde den Trick tun:

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

, aber es hat es versäumt, eine Warnung in IntelliJ loszuwerden „Ungeprüfter Aufruf‚compareTo (T)‘als Mitglied der rohen Art‚java.lang.Comparable‘“ auf der Linie:

return o1.compareTo(o2);

Answer 1

Ändern Sie es an:

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

Sie müssen das, weil Vergleichbar ist selbst ein generischer Typ.

Answer 2

Hier ist ein seltsamer Fall:

static class A {
    ...
}

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

Zum Glück Code wie die oben ist selten, aber nullCompare () nicht der Vergleich der Bs unterstützen, es sei denn es heißt, dass Vergleichbar mit T anwenden oder einem übergeordneten Klasse davon :

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

Auch wenn die meisten Leute werden nie aus den obigen zwicken profitieren, kann es nützlich sein, wenn APIs für exportierte Bibliotheken zu entwerfen.

Answer 3

Kann nicht bearbeiten, damit ich meine Antwort posten.

Sie müssen verschachtelten Typ-Parameter deklarieren, da Vergleichbar ist generisch.

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

Bitte beachten Sie, dass Vergleichbare , die flexibler macht. Sie erhalten die gleiche Methodendefinition auf Collections.sort siehe

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

Answer 4

Ich bin mir nicht sicher, dass diese Methode genericizing Sinn macht. Derzeit arbeitet das Verfahren auf jede Art von Vergleichbare; wenn Sie es genericize werden Sie es umsetzen müssen (mit genau den gleichen Code) mehrmals. Manchmal ist es möglich, zwei Objekte zu vergleichen, die nicht über einen gemeinsamen Vorfahren haben, und jede generische Version wird dies nicht zulassen.

Mit dem Generika Hinzufügen Sie keine Sicherheit, um den Code hinzuzufügen; Probleme der Sicherheit wird in dem Aufruf von compareTo auftreten. Was würde ich vorschlagen, einfach unterdrückt die Warnung. Es ist wirklich nicht Sie etwas Nützliches zu warnen.

Answer 5

Um es noch allgemeiner, könnte man sogar erlaubt es für zwei verschiedene Arten zu arbeiten. = P

  /**
   * 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 <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);
    }
  }