¿Puedo convertir el siguiente código para usar genéricos?

Question

Me estoy convirtiendo una aplicación para utilizar Java 1.5 y han encontrado el siguiente método:

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

Tu lugar ideal para realizar el método de tomar dos Comparables del mismo tipo, es posible convertir esto y cómo ?

pensé lo siguiente sería hacer el truco:

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

pero ha fracasado para deshacerse de una advertencia en IntelliJ "llamada sin marcar para 'compareTo (T)' como miembro del tipo de prima java' .lang.Comparable '" en la línea:

return o1.compareTo(o2); 

Answer 1

Cambiar a:

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

Necesitas que debido Compara ble es en sí mismo un tipo genérico.

Answer 2

He aquí un caso extraño:

static class A { 
    ... 
} 

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

suerte de código como la de arriba es raro, pero nullCompare() no apoyará comparación de B a menos que se afirma que Comparable puede aplicar a T o cualquier superclase de los mismos:

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

a pesar de que la mayoría de la gente nunca se beneficiarán del pellizco anteriormente, puede ser útil en el diseño de las API para las bibliotecas exportados.

Answer 3

No estoy seguro de que la genérica de este método tenga sentido. Actualmente el método funciona en cualquier tipo de Comparable; si lo genérico tendrá que implementarlo (con exactamente el mismo código) varias veces. Algunas veces es posible comparar dos objetos que no tienen un ancestro común, y cualquier versión genérica no lo permitirá.

Al agregar genéricos no agregará seguridad al código; cualquier problema de seguridad ocurrirá en la llamada a compareTo. Lo que sugeriría es simplemente suprimir la advertencia. En realidad, no te está advirtiendo sobre nada útil.

Answer 4

No se puede editar, así que tengo que publicar mi respuesta.

Debe declarar el parámetro de tipo anidado ya que Comparable es genérico.

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

Tenga en cuenta que comparable <? super T>, que lo hace más flexible. Verá la misma definición del método de Collections.sort

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

Answer 5

Para hacerlo aún más general, incluso se podría permitir que funcione para los dos tipos diferentes. = 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); 
    } 
    }