====== Subtyping & wildcards ======

PREV [[java:generics:alcune_novita_rispetto_a_java_1.4]] NEXT [[java:generics:confronti_tra_elementi]]

In Java un tipo A è un sottotipo di un altro tipo B  se questi sono legati da una clausola **extends** o **implements** 
<code java>A extends B o A implements B</java>
(Integer è sottotipo di Number, List<E> è sottotipo di Collection<E>)

Subtyping è riflessiva e transitiva:

//Se A è sottotipo di B allora B è supertipo di A//

Ogni tipo reference è sottotipo di Object ed Object è supertipo di ogni reference type

===== Principio di sostituzione =====
<code java>
interface Collection<E>{
...
public boolean add(E elem);
...
}
</code>
Principio di sostituzione: possiamo aggiungere Integer e Double  a collezioni di Numbers 
(Integer e Double sono sottotipi di Number)

<code java>
List<Number> numeri = new
 ArrayList<Number>();
numeri.add(2);

numeri.add(3.14);
assert
   numeri.toString().equals(
    "[2, 3.14]");
</code>

  * OK List<Number> è sottotipo di Collection<Number>
  * OK 2 ha tipo* Integer che è sottotipo di Number
  * OK 3.14 ha tipo* Double che è sottotipo di Number
  * Per ora tutto OK 

__Eccoci al dunque ...__

===== Wildcard con extends =====

<code java>
interface Collection<E>{
...
public boolean addAll(
  Collection<? extends E> c);
...
}
</code>

  * OK, posso inserire in una collezione di tipo E elementi di tipo E
  * ? extends E → OK, posso  inserire in una collezione di tipo E elementi appartenenti ad una collezione  di qualsiasi sottotipo di E

<code java>
List<Number> numeri = new ArrayList<Number>();
List<Integer> interi = Arrays.asList(1,2);
List<Double> doubles = Arrays.asList(2.78,3.14);
numeri.addAll(interi);
numeri.addAll(doubles)
</code>

  * OK Integer e Double sono sottotipi di Number
  * List<Integer> è sottotipo di List<? extends Number> (idem per Double)

<code sql>
List<Integer> interi = Arrays.asList(1,2);
List<? extends Number> numeri = interi;
numeri.add(3.14); // → Errore di compilazione
assert interi.toString().equals(
   "[1, 2, 3.14]");
</code>
List<? extends Number> può essere una lista di qualsiasi tipo di numero! Non è detto che sia una lista di Double!
:-( 


===== wildcard con super =====

<code java>
public static <T> void copia(List<? super T> dest, List<? extends T> src){
 for (int i=0; i < src.size(); i++) {

   dest.set(i,src.get(i)); // ← Attenzione
 }
}
</code>
//? super T → lista  destinazione di supertipo di T//
<code sql>
List<Object> oggetti = Arrays.<Object>asList(2,3.14,"four");
List<Integer> interi = Arrays.asList(5,6);
Collections.copia(oggetti, interi);
assert oggetti.toString().equals("[5, 6, four]");
</code>

===== Get and Put Principle =====

  * GET: Utilizzare il wildcard extends quando si deve solamente recuperare valori da una struttura
  * PUT: Utilizzare il wildcard super quando si deve solamente inserire dati in una struttura
  * GET and PUT: Non utilizzare i wildcard quando si deve sia prendere che inserire

==== Eccezioni al Get/Put principle ====
  * ? extends E → è possibile inserire null
  * ? super T → è possibile prelevare Object

==== Sporco trucco di programmazione ====

<code java>
public void rebox(
   Box<? extends Object> box) {
    reboxHelper(box);
}
private static <V> void reboxHelper(Box<V> box) {
    box.put(box.get());
}
</code>
Viene effettuata una chiamata ad un “helper” **senza** wildcard

===== Array =====

Il subtyping degli array in java è covariante: S sottotipo di T → S[] sottotipo di T[]
:!: Il codice seguente __viene compilato__
<code java>
Integer[] interi = 
   new Integer[] {1,2,3};
Number[] numeri = interi;
numeri[2] = 3.14; // --> oops
</code>

ma attenzione che a runtime viene lanciato un errore
<code>
Exception in thread "main"
java.lang.ArrayStoreException: java.lang.Double
// numeri--> 1 2 3.14
</code>

Passiamo adesso ai generics
<code java>
List<Integer>  interi= Arrays.asList(1,2,3);
List<Number> numeri = interi; → non compila!
numeri.add(3.14);
</code>
il codice __non compila__  il Subtyping per i generics è controvariante: 
S supertipo di T → List<S> è sottotipo di List <? super T> 

==== Covariante ====
<code>
   
   S        ----- extends -----> T
   S[]      ----- extends -----> T[]

   String   ----- extends -----> Object
   String[] ----- extends -----> Object[]

</code>

==== Controvariante ====
<code>
     S                ----- extends -----> T
     List<T>          ----- extends -----> List <? super S>

     String           ----- extends -----> Object
     List<Object>     ----- extends -----> List<? super String>
</code>

==== Cattura del wildcard ====
Quando viene invocato un metodo generico il parametro di tipo deve essere scelto in modo da “combaciare” con il tipo rappresentato dal wildcard → //wildcard capture//
<code java>
public static  <T>  void reverse(List<T> list)
public static void reverse(List<?> list)
</code>
<?> è un sinonimo di <? extends Object>


<code java>
public static  <T>  void reverse(List<T> list){
List<T> tmp = new ArrayList<T>(list);
for (int i = 0 ; i < list.size() ; i++){
list.set(i, tmp.get(list.size() -i - 1) );
}
}
</code>
il seguente codice __non compila__
<code java>
public static void reverse(List<?> list){
List<Object> tmp = new ArrayList<Object>(list);
for (int i = 0 ; i < list.size() ; i++){
list.set(i, tmp.get(list.size() -i - 1) );
}
}
</code>

errore di compilazione
<code>
The method set(int, capture#3-of ?) in the type List<capture#3-of ?> is not applicable for the arguments (int, Object)
</code>

===== Restrizioni del wildcard =====
  * Creazione dell'istanza
  * Chiamata a metodo generico
  * Supertipo
==== Creazione dell'istanza ====

<code java>
List<?> l = new ArrayList<?>();
   NO! Errore di compilazione

List<? super Number >  s = new ArrayList<Number>(); 
  OK
</code>
==== Chiamata a metodo generico ====

<code java>
public class Lista {
public static <T> List<T>factory() { return new ArrayList<T>(); }
} .. OK
List<?> l = Lista.factory(); OK
List<?> l2 = Lista.<Object>factory(); OK
List<?> l3 = Lista.<?>factory(); → ERRORE
List<?> l4 = Lista.<List<?>>factory(); OK 
</code>
==== Supertipo ====
<code java>
Class Lista extends ArrayList<?> {…} → NO
Class Lista2 implements List<?> {…} → NO
Class List3  implements  ArrayList<List<?>> {…} → OK
</code>

NEXT [[java:generics:confronti_tra_elementi]]