Considerar el código:

public abstract class Item<T> implements Comparable<T>
{
    protected T item;

    public int compareTo(T o)
    {
        return 0; //this doesn't matter for the time being
    }
}

public class MyItem<T> extends Item<String>
{
    T object;
}

public class Foo<T>
{
    protected ArrayList<T> list;
}

public class Bar<V> extends Foo<MyItem<V>>
{
    public void sort()
    {
        Collections.sort(list);
    }
}

El tipo de la llamada da el error:

Obligado desajuste: El método genérico sort(List< T >) de tipo de Colecciones no es aplicable para los argumentos (ArrayList< Mielemento< T > >). El tipo inferido Mielemento< T > no es un sustituto válido para la delimitado el parámetro < T extends Comparable< ? super T > >

¿Por qué esta mal?

Si MyItem<V> implementa Comparable entonces ¿por qué no es un sustituto?

Lo siento si esto ha sido preguntado, pero creo que la pregunta es algo específico.

OriginalEl autor terrorcell | 2013-07-19

4 Comentarios

  1. 12

    Realmente explicación más detallada de este error le da a su javac sí mismo:

    java: no adecuado de los métodos para sort(java.util.ArrayList<MyItem<V>>)

    método java.util.Collections.<T>sort(java.util.List<T>,java.util.Comparator<?
    super T>)
    no es aplicable (no se puede crear una instancia de argumentos porque real y formal de las listas de argumentos difieren en longitud)

    método java.util.Collections.<T>sort(java.util.List<T>) no es aplicable (tipo inferido no se ajusta a declarado atado(s) inferirse: MyItem<V> atado(s): java.lang.Comparable<? super MyItem<V>>)

    Así que la pregunta principal es:

    ¿por qué es el método Collections.<T>sort(java.util.List<T>)) no aplicable?

    La respuesta es:

    porque en Collections.<T>sort(java.util.List<T>) declaración de método hay límites en el parámetro T: <T extends Comparable<? super T>>.

    En otra palabras, T debe implementar Comparable de la interfaz en sí mismo. Por ejemplo String clase implementa dicha interfaz: ...implements ... Comparable<String>.

    En su caso Item clase no implementa dicha interfaz:

    Item<T> implements Comparable<T> no es la misma cosa como Item<T> implements Comparable<Item<T>>.

    Así que, para resolver este problema, debe cambiar su Item clase a esta:

    public abstract class Item<T> implements Comparable<Item<T>>
    {
        protected T item;
    
        public int compareTo(Item<T> o)
        {
            return 0; //this doesn't matter for the time being
        }
    }
    Que era perfecto. Saludos! Para aclarar, he incluido las clases extra porque el código que siempre es una forma mucho más simplificada versión de mi código real, y yo no estaba seguro de dónde era el problema. Estoy totalmente perdido que yo apenas podía cambiar la comparación real de sí mismo. Gracias de nuevo.
    Mejor : public abstract class Item<T> implements Comparable<? extends Item<T>> – no ?

    OriginalEl autor Andremoniy

  2. 2

    Para los objetos de tipo X a ser comparable con cada uno de los otros, de la clase X tiene que aplicar exactamente Comparable<X>.

    Esto no es lo que hace el código, tienes una clase Item<T> y se están implementando Comparable<T> en lugar de Comparable<Item<T>>. Esto significa que Item<T> puede ser comparado con T, pero no con Item<T>, que es necesario.

    Cambiar su Item<T> clase a:

    public abstract class Item<T> implements Comparable<Item<T>>
    {
        protected T item;
    
        @Override
        public int compareTo(Item<T> o)
        {
            return 0; //this doesn't matter for the time being
        }
    }
    «Para los objetos de tipo X para ser comparables unos con otros, de clase X se tiene que aplicar exactamente Comparables<X>.» No necesariamente tienen que ser exactamente. X podría implementar Comparable<SomeSuperTypeOfX>
    Oh, cierto, claro.

    OriginalEl autor Dukeling

  3. 1

    Sólo cambiar la clase como sigue:

         public class MyItem<T> extends Item<String> implement Comparable<MyItem<T>>
         {
             T object;
         }

    O

           public abstract class Item<T> implements Comparable<MyItem<T>>
           {
               protected T item;
    
               public int compareTo(MyItem<T> o)
               {
                  return 0; //this doesn't matter for the time being
           }

    }

    El error consejos nos ha mostrado.Espero que sea útil.

    OriginalEl autor Sstx

  4. 0

    Usted no necesita tener la clase MyItem generified sólo para ver el efecto. La siguiente clase es suficiente para ver lo que sucede:

    public class MyItem extends Item<String> {}

    Ahora usted tiene la siguiente llamada:

    Collections.sort(list);

    Como morgano declaró correctamente, el método de ordenación tendrá una colección que se parametriza con un tipo T que debe ser comparable a la de T. Su MyItem clase es la ampliación de Item<String>, lo que resulta en MyItem siendo comparable a la Strings.

    Con un pequeño interruptor en la clase que implementa la Comparable interfaz, usted obtendrá el resultado esperado:

    public abstract class Item<T> {
        protected T item;
    }
    
    public class MyItem extends Item<String> implements Comparable<MyItem> {
        @Override
        public int compareTo(MyItem o) {
            return item.compareTo(o.item); //just an example
        }
    }

    Y ahora la llamada a Collections.sort(list) de trabajo.

    OriginalEl autor Seelenvirtuose

Dejar respuesta

Please enter your comment!
Please enter your name here