Differenza tra un carattere jolly non associato e un tipo non elaborato

Stavo leggendo di generici e non ho capito la necessità di caratteri jolly non associati e di come si differenzia dal tipo grezzo. Ho letto questa domanda ma ancora non l’ho capito chiaramente. Nella pagina del tutorial Java per la wildcard non associata sono arrivato sotto due punti e non ho capito il primo punto:

  • Se stai scrivendo un metodo che può essere implementato usando la funzionalità fornita nella class Object .
  • Quando il codice utilizza metodi nella class generica che non dipendono dal parametro type. Ad esempio, List.size() o List.clear() . In effetti, la Class È così spesso usata perché la maggior parte dei metodi nella Class non dipende da T

Qualcuno può spiegare la differenza tra wildcard non associato e tipo grezzo in un linguaggio comune.

In che modo List Differisce da List ?

Come List Differisce da List

La differenza principale è che la prima riga viene compilata ma la seconda no:

 List list = new ArrayList (); List list = new ArrayList (); 

Tuttavia, poiché non si conosce il tipo generico di List , Non è ansible utilizzare i suoi metodi parametrizzati:

 List list = new ArrayList (); list.add("aString"); //does not compile - we don't know it is a List list.clear(); //this is fine, does not depend on the generic parameter type 

Per quanto riguarda la differenza con i tipi non elaborati (senza generici), il codice seguente viene compilato e funziona correttamente:

 List list = new ArrayList (); list.add("aString"); list.add(10); 

Come la List Differisce da List ?

  List l1 = new ArrayList(); List l2 = new ArrayList(); l1.add("Object"); //l2.add("Object"); incorrect l2.add(null); 

È ansible aggiungere solo valori null List

Personalmente, ho trovato utile questo collegamento aggiuntivo dal tutorial Java sui caratteri jolly .

Una delle principali differenze che vedo tra List E List è che il primo può essere sempre utile solo per leggere dagli elementi (a meno che tu non voglia aggiungere null ), quest’ultimo permette (non controllato) l’aggiunta di oggetti digitati arbitrariamente a con effetti collaterali possibilmente inaspettati.

L’elenco è utile in una firma del metodo per chiamare metodi che non richiedono mai il parametro type, ad esempio, leggono dall’elenco o lo ruotano, ad esempio.

 void someMethod(List list) { list.clear(); // I will never add anything to the list in here } 

Non aggiungerai mai nulla o modificheresti in altro modo la lista in relazione al tipo che detiene dato che non puoi aggiungere nulla all’elenco tranne null nei metodi con questa firma e quindi non romperai mai la sicurezza del tipo. Raw List, d’altra parte, puoi fare qualsiasi cosa, che come tutti sappiamo può causare una violazione della sicurezza di tipo.

 void someMethod2(List list) { list.add(new WeaselFurBrush()); } List list1 = new ArrayList(); someMethod2(list1);// oops 

Qualcuno può spiegare la differenza tra wildcard non associato e tipo grezzo in un linguaggio comune.

Il tipo di carattere jolly non associato può mantenere invariato il tipo di raccolta e il tipo non elaborato. Come dice Joshua Bloch nel suo efficace Java ,

È ansible inserire qualsiasi elemento in una raccolta con un tipo non elaborato, corrompendo facilmente il tipo di invariante della raccolta (come dimostrato dal metodo unsafeAdd a pagina 112); non puoi mettere alcun elemento (diverso da null) in una Collezione .

Pertanto, se si assegna un elenco di tipi parametrizzati a un elenco di tipi di caratteri jolly non associati, verrà mantenuto l’ invarianza di tipo della raccolta .

 List list1 = new ArrayList(); list1.add("foo"); list1.add("bar"); List list2 = list1; 

Se si assegna un elenco di tipo non elaborato i cui elementi sono di tipi diversi, il tipo di carattere jolly non associato non manterrà invariato il tipo di raccolta , poiché l’elenco è originariamente di tipo variante.

 List list1 = new ArrayList(); list1.add(1); list1.add("foo"); List list2 = list1;