Tipi di jolly nidificati Java più volte o come parametro di tipo generico

Question

Ho una classe con un parametro di tipo limitato con tipi limitati con caratteri jolly nidificati. Nella classe ho bisogno di usare i tipi dei parametri annidati legati in più metodi. Esiste un modo per definire il tipo con caratteri jolly come parametro generico invece di assegnarlo a un nome di variabile generico in modo che possa essere facilmente referenziato in più punti?

Il modo in cui la classe è implementata ora è come

class AbstractManager<F extends Filter<? extends Criteria<? extends Type>>> 
    { 
     protected void setFilter(F filter) 
     { 
     setCriteria(f.getCriteria()); 
     } 

     protected <T extends Criteria<? extends Type>> void setCriteria(List<T> criteria) 
     { 
     } 

     protected <T extends Criteria<? extends Type>> void doSomethingWithCriteria(List<T> criteria) 
     { 
      ... 
     } 
    } 

che non vincolato in realtà limitare il tipo di lista per il tipo di filtro, ma è abbastanza buono nella nostra situazione. Idealmente, il tipo dell'elenco sarebbe limitato al tipo del filtro utilizzando un costrutto che potrebbe associare il tipo inferito del filtro a un nome simile a un parametro di tipo limitato su un metodo, ma a livello di classe.

Fondamentalmente vorrei fare qualcosa di simile

class <G extends Criteria<? extends Type> AbstractManager<F extends Filter<G>> 

Da quello che so e può trovare, questo non è possibile, ma speravo che forse c'era una caratteristica oscuro o nuova funzionalità di Java 7 che renderebbe tutto ciò possibile So che è possibile specificare un secondo parametro di tipo come

class AbstractManager<F extends Filter<G>, G extends Criteria<? extends Type>> 

ma non voglio che le classi figlie di avere per specificare G quando il compilatore in grado di determinare esso.

L'unica opzione/soluzione possibile ho potuto trovare è quello di avere una sottoclasse poco profonda con metodi di fabbrica riportati nella solution a questa domanda Nested Type Parameters in Java e in Java generics - use same wildcard multiple times

Answer 1

Se ho capito ciò che si intende farebbe, cambierebbe la semantica della tua classe. In questo momento nella classe corrente, si potrebbe avere, ad esempio:

class T1 extends Type {} 
class T2 extends Type {} 
class C1 extends Criteria<T1> {} 
class C2 extends Criteria<T2> {} 
class C3 extends Criteria<T2> {} 
class F1 extends Filter<C1> {} 
class Manager extends AbstractManager<F1> {} 

E poi, anche se Manager è basato sulla F1, un po 'di codice utente sarebbe perfettamente legale se lo ha fatto:

Manager m = new Manager(); 
C2 c2 = new C2(); 
C3 c3 = new C3(); 
m.setCriteria(Arrays.asList(new C2[]{c2}); 
m.doSomethingWithCriteria(Arrays.asList(new C3[]{c3}); 

Non so se è stato il tuo intento, ma è legale (dal punto di vista del compilatore). Tuttavia, se si fosse in qualche modo in grado di nominare quel tipo di caratteri jolly, usando quel nome nei propri metodi, si vincolerebbe l'utente della classe a utilizzare lo stesso tipo in tutti i metodi. In altre parole, nel mio esempio i metodi dovrebbero essere chiamati con liste di C1.

In conclusione, se si desidera la flessibilità del proprio esempio, è necessario ripetere il carattere jolly; ma se si vuole un vincolo che i metodi usano gli stessi criteri come il filtro del gestore, poi in realtà ha dato la soluzione:

class AbstractManager<F extends Filter<G>, G extends Criteria<? extends Type>> 

(o creare un sotto-tipo dedicato per evitare la ripetizione, come lei ha ricordato (tutto ciò che non ti piace?))