Qual è l'uso di dire <? si estende SomeObject> invece di <SomeObject>

Question

quindi cercavo di sopra del codice Java e siamo capitati:

List<? extends SomeObject> l; 

fondamentalmente questa lista accetta tutti gli oggetti che sono una sorta di SomeObject - stesso o dei suoi eredi someObject. Ma secondo polymophism, è eredi possono anche essere seens come SomeObject, quindi questo dovrebbe funzionare così:

List<SomeObject> l; 

Allora perché qualcuno dovrebbe utilizzare la prima opzione quando il secondo è chiaramente definito e praticamente identici?

Answer 1

List<SomeObject> l; 

In questo non si può dire List<SomeObject> l = new ArrayList<SubClassOfSomeObjectClass>; (non ammessi) wheres per

List<? extends SomeObject> l; 

si può dire

List<? extends SomeObject> l = new ArrayList<SubClassOfSomeObject>; (ammessi)

Ma nota che in List<? extends SomeObject> l = new ArrayList<SubClassOfSomeObject>; si non si può aggiungere nulla alla lista il vostro l perché? rappresenta una classe sconosciuta (Tranne nullo di corso).

Update: Per la tua domanda nel commento What could I possibly do with a list if I cannot add anything to it?

Consideriamo ora un caso in cui è necessario scrivere una funzione per stampare l'elenco, ma mente si deve accettare solo un elenco con oggetti che sono sottoclassi del tuo SomeObject. In questo caso, come ho detto in precedenza non è possibile utilizzare

public void printList(List<SubClassOfSomeObjectClass> someList)

Allora, cosa faresti? Si potrebbe fare qualcosa di simile

public void printList(List<? extends SomeObject> someList) { 
     for(SomeObject myObj : someList) { 
      //process read operations on myObj 
     } 

Answer 2

List<? extends SomeObject> l; non accetta new SomeObject() ma List<SomeObject> l; fa.

ciò che è anche non funziona: List<SomeObject> l = new ArrayList<SubTypeOfSomeObject>()

che cosa sta lavorando: List<? extends SomeObject> l = new ArrayList<SubTypeOfSomeObject>()

Answer 3

Come la prima risposta,

List<? extends SomeObject> l; 

must contiene oggetti che ereditano da SomeObject, non qualche SomeObject diretta.

Answer 4

Il collegamento chiave che si desidera leggere è http://docs.oracle.com/javase/tutorial/extra/generics/wildcards.html che spiega in dettaglio il carattere jolly generico.

List<SomeObject> non corrisponde a List<? extends SomeObject>.Osservare il seguente

List<Object> x = new ArrayList<Object>(); 
List<String> y = new ArrayList<String>(); 
// x = y; Will throw Compilation exception 
List<? extends Object> z = y; //will pass compilation 

Si consiglia di osservare che è possibile aggiungere dire una stringa sia per il x e la lista y tuttavia sarà utile quando si scrive dire una funzione di libreria (come il printCollection nell'esempio mostrato nel link) piuttosto che accettare un Collection<Object> nel qual caso un utente non può passare il suo elenco di stringhe che ha al tuo metodo, se accetti allora l'utente può passare il suo Collection<Apple>, Collection<Orange> ecc senza dover creare esplicitamente un altro elenco.

Answer 5

X non può essere aggiunto a List<Y> anche se X può essere convertito in Y.

Quindi, nel tuo secondo caso, se List<X> l; è stato permesso di aggiungere sottoclasse di X, che sarebbe rompere il principio di base della sicurezza di tipo