Quello che mi manca nelle altre risposte è un riferimento a come ciò si collega alla co-e contraddizione e ai sottotipi e supertipi (cioè polimorfismo) in generale e Java in particolare. Questo può essere ben compreso dall'OP, ma per ogni evenienza, ecco qui:
covarianza
Se hai una classe Automobile, allora Care Trucksono i loro sottotipi. Qualsiasi automobile può essere assegnata a una variabile di tipo Automobile, questo è ben noto in OO e si chiama polimorfismo. Covarianza si riferisce all'utilizzo di questo stesso principio in scenari con generici o delegati. Java non ha delegati (ancora), quindi il termine si applica solo ai generici.
Tendo a considerare la covarianza come un polimorfismo standard ciò che ti aspetteresti di lavorare senza pensare, perché:
List<Car> cars;
List<Automobile> automobiles = cars;
// You'd expect this to work because Car is-a Automobile, but
// throws inconvertible types compile error.
Il motivo dell'errore è, tuttavia, corretto: List<Car> non eredita da List<Automobile>e quindi non può essere assegnato l'uno all'altro. Solo i parametri di tipo generico hanno una relazione ereditaria. Si potrebbe pensare che il compilatore Java semplicemente non sia abbastanza intelligente da capire correttamente il tuo scenario lì. Tuttavia, puoi aiutare il compilatore dandogli un suggerimento:
List<Car> cars;
List<? extends Automobile> automobiles = cars; // no error
controvarianza
Il contrario della co-varianza è la contraddizione. Laddove nella covarianza i tipi di parametro devono avere una relazione di sottotipo, nella contraddizione devono avere una relazione di sottotipo. Questo può essere considerato come un'eredità limite superiore: qualsiasi supertipo è consentito e include il tipo specificato:
class AutoColorComparer implements Comparator<Automobile>
public int compare(Automobile a, Automobile b) {
// Return comparison of colors
}
Questo può essere usato con Collections.sort :
public static <T> void sort(List<T> list, Comparator<? super T> c)
// Which you can call like this, without errors:
List<Car> cars = getListFromSomewhere();
Collections.sort(cars, new AutoColorComparer());
Potresti anche chiamarlo con un comparatore che confronta gli oggetti e usarlo con qualsiasi tipo.
Quando usare il contra o la varianza?
Forse un po 'OT, non l'hai chiesto, ma aiuta a capire come rispondere alla tua domanda. In generale, quando ottieni qualcosa, usa la covarianza e quando metti qualcosa, usa la contraddizione. Questo è meglio spiegato in una risposta alla domanda Stack Overflow Come si usa la contravarianza nei generici Java?.
Allora di cosa si tratta List<? extends Map<String, String>>
Si utilizza extends, quindi si applicano le regole per la covarianza . Qui hai un elenco di mappe e ogni elemento che memorizzi nell'elenco deve essere Map<string, string>o derivare da esso. L'affermazione List<Map<String, String>>non può derivare Map, ma deve essere a Map .
Quindi, funzionerà quanto segue, poiché TreeMaperedita da Map:
List<Map<String, String>> mapList = new ArrayList<Map<String, String>>();
mapList.add(new TreeMap<String, String>());
ma questo non:
List<? extends Map<String, String>> mapList = new ArrayList<? extends Map<String, String>>();
mapList.add(new TreeMap<String, String>());
e neanche questo funzionerà perché non soddisfa il vincolo di covarianza:
List<? extends Map<String, String>> mapList = new ArrayList<? extends Map<String, String>>();
mapList.add(new ArrayList<String>()); // This is NOT allowed, List does not implement Map
Cos'altro?
Questo è probabilmente ovvio, ma potresti aver già notato che l'uso della extendsparola chiave si applica solo a quel parametro e non al resto. Vale a dire, non verrà compilato quanto segue:
List<? extends Map<String, String>> mapList = new List<? extends Map<String, String>>();
mapList.add(new TreeMap<String, Element>()) // This is NOT allowed
Supponiamo che tu voglia consentire qualsiasi tipo nella mappa, con una chiave come stringa, che puoi usare extendsu ogni parametro di tipo. Cioè, supponiamo che tu elabori XML e desideri memorizzare AttrNode, Element ecc in una mappa, puoi fare qualcosa del tipo:
List<? extends Map<String, ? extends Node>> listOfMapsOfNodes = new...;
// Now you can do:
listOfMapsOfNodes.add(new TreeMap<Sting, Element>());
listOfMapsOfNodes.add(new TreeMap<Sting, CDATASection>());