parametri generici ridondanti

Question

ho questo due interfacce e classi:

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; 
} 

tutto funziona come desiderato. Ma a mio parere il secondo parametro generico in GenericRepository (K) è ridondante. Perché so che è un MyEntity identificabili, penso che sarebbe bello se posso finalmente usare in questo modo:

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

Ma sto cercando cose diverse senza riuscirvi. È possibile? Se no, perché no?

UPDATE: Rispondere ad alcune risposte. Penso che il compilatore sappia qualcosa su quale tipo è il generico in MyEntity. Ad esempio:

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

Non penso che tu possa ometterlo. Con T extends Identifiable<K> si vuole dire che il parametro di tipo generico deve essere un Identifiable. Dato che Identifiable è una classe generica, è necessario menzionare anche il suo parametro di tipo generico (se si vuole giocare secondo le regole che sono - se lo si omette, si perde tutta la sicurezza di tipo generico per GenericRepository, a causa delle regole di retrocompatibilità). Si noti inoltre che K viene effettivamente utilizzato come tipo di parametro di GenericRepository.get. E poiché quel tipo può essere diverso da T, è necessario soddisfare il compilatore dichiarandolo come un altro parametro di tipo generico di GenericRepository. Altrimenti il ​​compilatore non ha modo di sapere cosa sia K.

Answer 2

Non è ridondante dal punto di vista della classe GenericRepository. Quando ha metodi come T get(K id), non può sapere quali tipi dell'argomento id può accettare diversamente. È possibile scrivere il seguente:

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

Ora non c'è bisogno di scrivere Long come un parametro di tipo, ma si perde la possibilità di verificare se il metodo get viene utilizzato correttamente al momento della compilazione. Quindi la variabile type ha uno scopo specifico.

E per quanto riguarda la dichiarazione di campo, quando si dispone di un tipo generico, è necessario specificare tutte le variabili di tipo che utilizza. Naturalmente, si potrebbe obiettare che sarebbe bello se la lingua potesse capire che uno dei valori dei parametri può essere dedotto dall'altro, ma è discutibile.

Answer 3

Se non sbaglio, i generici verranno tutti compilati come se fossero solo Object. Ora la sintassi è (difficile) verificata per garantire che non si stia mettendo mela con le arance perché i generici sono stati aggiunti dopo la progettazione iniziale di Java. questo è il motivo per cui i generici sono così costretti ...

Answer 4

Perché non è possibile rimuovere secondo K da,

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

Quindi, piuttosto che averlo come sopra, possiamo avere come

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

By questo possiamo fare quello che vuoi fare.

Answer 5

Funzionerebbe con (vale a dire.compila)

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

ma si dice comunque che Identifiable è un tipo non elaborato e che dovrebbe essere parametrizzato.

Spero che aiuti.

Answer 6

Non molto si può fare, altro che introdurre un'interfaccia che solo affina GenericRepository

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

Poi si può avere

private LongKeyedRepository<MyEntity> myEntityRepository; 

ecc