Java Generics Puzzler, estensione di una classe e utilizzo di caratteri jolly

Question

Ho battuto la testa contro questo per un po 'e ho pensato che forse alcuni occhi nuovi vedranno il problema; Grazie per il tuo tempo.

import java.util.*; 

class Tbin<T> extends ArrayList<T> {} 
class TbinList<T> extends ArrayList<Tbin<T>> {} 

class Base {} 
class Derived extends Base {} 

public class Test { 
    public static void main(String[] args) { 
    ArrayList<Tbin<? extends Base>> test = new ArrayList<>(); 
    test.add(new Tbin<Derived>()); 

    TbinList<? extends Base> test2 = new TbinList<>(); 
    test2.add(new Tbin<Derived>()); 
    } 
} 

Utilizzo di Java 8. Sembra a me come la creazione diretta del contenitore in test è equivalente al contenitore in test2, ma il compilatore dice:

Test.java:15: error: no suitable method found for add(Tbin<Derived>) 
    test2.add(new Tbin<Derived>()); 
     ^

Come faccio a scrivere Tbin e TbinList quindi l'ultima riga è accettabile?

Nota che in realtà sto aggiungendo il dattiloscritto Tbin s che è il motivo per cui ho specificato Tbin<Derived> nell'ultima riga.

Answer 1

OK, ecco la risposta:

import java.util.*; 

class Tbin<T> extends ArrayList<T> {} 
class TbinList<T> extends ArrayList<Tbin<? extends T>> {} 

class Base {} 
class Derived extends Base {} 

public class Test { 
    public static void main(String[] args) { 

    TbinList<Base> test3 = new TbinList<>(); 
    test3.add(new Tbin<Derived>()); 

    } 
} 

Come mi aspettavo, specie di evidente una volta l'ho visto. Ma un sacco di battute per arrivare qui. I generici Java sembrano semplici se si guarda solo al codice funzionante.

Grazie a tutti per essere una cassa di risonanza.

Answer 2

Si sta utilizzando un carattere jolly limitato (TbinList<? extends Base>> ...). Questo jolly ti impedirà di aggiungere elementi all'elenco. Se vuoi maggiori informazioni, ecco la sezione su Wildcards nella documentazione.

Answer 3

non è possibile aggiungere oggetti a TbinList<? extends Base>, non è garantito quali oggetti si stanno inserendo nell'elenco. Si suppone di leggere i dati da test2 quando si utilizza jolly extends

Se dichiarato come TbinList<? extends Base> che significa che è tutte le sottoclassi della classe base o classe di base stessa, e quando si inizializza esso si utilizza diamanti diversa classe concreta nome, rende il tuo test2 non ovvio che rende più difficile dire quali oggetti possono essere inseriti. Il mio suggerimento è di evitare che tale dichiarazione sia pericolosa, potrebbe non avere errori di compilazione ma è un codice orribile, potresti aggiungere qualcosa, ma potresti anche aggiungere la cosa SBAGLIATA che infrange il tuo codice.

Answer 4

È possibile definire i tipi generici come segue:

class Tbin<T> extends ArrayList<T> {} 
class TbinList<K, T extends Tbin<K>> extends ArrayList<T> {} 

Poi si creerebbe istanza come:

TbinList<? extends Base, Tbin<? extends Base>> test2 = new TbinList<>(); 
test2.add(new Tbin<Derived>()); 

Answer 5

Sostituzione della definizione di TbinList con

class TbinList<T> extends ArrayList<Tbin<? extends T>> {} 

e definendo test2 con

TbinList<Base> test2 = new TbinList<>(); 

risolverebbe invece il problema.

Con la tua definizione sei finito con un ArrayList<Tbin<T>> dove T è una qualsiasi classe fissa che si estende Base.

Answer 6

Questo accade a causa del modo in cui capture conversion opere:

There exists a capture conversion from a parameterized type G<T1,...,Tn> to a parameterized type G<S1,...,Sn> , where, for 1 ≤ i ≤ n :

• If Ti is a wildcard type argument of the form ? extends Bi , then Si is a fresh type variable [...].

Capture conversion is not applied recursively.

Annotare il bit finale. Allora, che cosa questo significa è che, dato un tipo come questo:

Map<?, List<?>> 
//  │ │ └ no capture (not applied recursively) 
//  │ └ T2 is not a wildcard 
//  └ T1 is a wildcard 

Solo "al di fuori" jolly vengono catturati. Il Map jolly chiave viene catturato, ma il List elemento jolly non è. Questo è il motivo per cui, ad esempio, siamo in grado di aggiungere a un List<List<?>>, ma non un List<?>. La posizione del jolly è ciò che conta.

Portare questo oltre a TbinList, se abbiamo un ArrayList<Tbin<?>>, il jolly è in un luogo dove non viene catturato, ma se abbiamo un TbinList<?>, il jolly è in un luogo in cui viene catturato.

Come ho accennato nei commenti, un test molto interessante è questo:

ArrayList<Tbin<? extends Base>> test3 = new TbinList<>(); 

Otteniamo questo errore:

error: incompatible types: cannot infer type arguments for TbinList<> 
    ArrayList<Tbin<? extends Base>> test3 = new TbinList<>(); 
                 ^
    reason: no instance(s) of type variable(s) T exist so that TbinList<T> conforms to ArrayList<Tbin<? extends Base>>

Quindi non c'è modo di farlo funzionare così com'è. Una delle dichiarazioni di classe deve essere cambiata.

---

Inoltre, pensa in questo modo.

Supponiamo di avere:

class Derived1 extends Base {} 
class Derived2 extends Base {} 

E dal momento che un jolly consente subtyping, siamo in grado di fare questo:

TbinList<? extends Base> test4 = new TbinList<Derived1>(); 

dovremmo essere in grado di aggiungere un Tbin<Derived2>-test4? No, questo sarebbe inquinamento da cumulo. Potremmo finire con Derived2 s galleggianti intorno in un TbinList<Derived1>.