parámetros genéricos redundantes

Question

que tienen estas dos interfaces y clases:

public interface Identifiable<T> { 
    T getId(); 
} 

public interface GenericRepository<T extends Identifiable<K>, K> { 
    T get(K id); 
} 

public class MyEntity implements Identifiable<Long> { 

    private Long id; 

    public Long getId() { 
     return id; 
    } 
} 

public class MyService { 
    private GenericRepository<MyEntity, Long> myEntityRepository; 
} 

todo funciona como se desea. Pero, en mi opinión, el segundo parámetro genérico en GenericRepository (K) es redundante. Porque sé que es un myEntity identificable, creo que sería muy bueno si por fin puedo utilizar de esta manera:

public class MyService { 
    private GenericRepository<MyEntity> myEntityRepository; 
} 

Pero estoy tratando cosas diferentes sin tener éxito. ¿Es posible? ¿Si no, porque no?

ACTUALIZACIÓN: Respondiendo algunas respuestas. Creo que el compilador sabe algo sobre qué tipo es el genérico en MyEntity. Por ejemplo:

public class MyEntityGenericRepository implements GenericRepository<MyEntity, Long> { 
    // compiles... 
} 

public class MyEntityGenericRepository implements GenericRepository<MyEntity, String> { 
    // compiler says: "Bound mismatch: The type MyEntity is not a valid substitute for the bounded parameter <T extends Identifiable<K>> of the type GenericRepository<T,K>" 
} 

Answer 1

No creo que pueda omitirlo. Con T extends Identifiable<K>, quiere decir que el parámetro de tipo genérico debe ser Identifiable. Desde Identifiable es una clase genérica, es necesario mencionar su parámetro de tipo genérico también (si desea jugar con las reglas que es - si se omite, se pierde toda la seguridad de tipo genérico para GenericRepository, debido a las normas de compatibilidad hacia atrás). Tenga en cuenta también que K se usa realmente como el tipo de parámetro de GenericRepository.get. Y dado que ese tipo puede ser diferente de T, debe cumplir el compilador al declararlo como otro parámetro de tipo genérico de GenericRepository. De lo contrario, el compilador no tiene forma de saber qué es K.

Answer 2

No es redundante desde el punto de vista de la clase GenericRepository. Cuando tiene métodos como T get(K id), no puede saber qué tipos del argumento id puede aceptar de otro modo. Puede escribir lo siguiente:

interface GenericRepository<T extends Identifiable<?>> { 
    T get(Object id); 
} 

Ahora usted no tiene que escribir Long como un parámetro de tipo, pero se pierde la posibilidad de comprobar si se utiliza el método get correctamente en tiempo de compilación. Entonces la variable tipo sirve para un propósito específico.

Y en cuanto a la declaración del campo, cuando se tiene un tipo genérico, hay que especificar todas las variables de tipo que utiliza. Por supuesto, podría argumentar que sería bueno si el lenguaje pudiera entender que uno de los valores de los parámetros puede inferirse del otro, pero es discutible.

Answer 3

Si no me genéricos equivocadas todas serán compilados como si fueran simplemente Object. Ahora la sintaxis es (difícil) comprobada para asegurarse de que no está poniendo manzanas con naranjas porque se agregaron genéricos después del diseño inicial de Java. es por eso que los genéricos son tan limitados ...

Answer 4

¿Por qué no se puede quitar segundo K de,

public interface GenericRepository<T extends Identifiable<K>, K> { 

Así que en lugar de tener que el anterior, podemos tener como

public interface GenericRepository<T extends Identifiable<K>> { 

Por esto podemos hacer lo que quieras hacer.

Answer 5

que trabajaría con (es decir,compilar)

public interface GenericRepository<T extends Identifiable> { 
    T get(T id); 
} 

pero dice, no obstante, que Identificable es un tipo sin procesar y que debe ser parametrizado.

Espero que ayude.

Answer 6

No hay mucho que hacer, aparte de introducir una interfaz que solo refina GenericRepository

public interface LongKeyedRepository<T extends Identifiable<Long>> 
     extends GenericRepository<T, Long> { { 
    //No new methods need to be defined 
    } 

Entonces usted puede tener

private LongKeyedRepository<MyEntity> myEntityRepository; 

etc.