====== Dichiarazioni di variabili ======
PREV [[java:generics:confronti_tra_elementi]]

NEXT [[evoluzione_non_rivoluzione]]

===== Costruttori =====
<code java>
public class Coppia<P,S> {
 private final P primo; 
 private final S secondo; 
 public P getPrimo() {
  return primo; } 
 public S getSecondo() {
  return secondo; } 
 public Coppia(P primo, S secondo) {
  this.primo = primo;
  this.secondo = secondo; }}

</code>

In una classe generica i parametri di tipo appaiono nell'intestazione che dichiara la classe
**non nel costruttore!**

<code java>
Coppia<String, Integer> c = new Coppia<String, Integer>("Ciao", 1);
assert c.getPrimo().equals("Ciao") && c.getSecondo().equals(1);
</code>
OK

<code java>
Coppia<String,Integer> c = new Coppia("Ciao",1);
</code>

__Warning__! __UncheckedWarning__ L'istruzione è legale ma genera un warning //(non è detto che valga la Cast Iron Guarantee)//

===== Static =====
<code java>
List<Integer> interi = Arrays.asList(1,2,3);
List<String> stringhe = Arrays.asList("ciao","mondo");
assert interi.getClass() == stringhe.getClass();
</code>
I generics sono implementati tramite **type erasure** List<String> e List<Integer> a tempo di compilazione sono List

Type erasure →
  * variabili e metodi statici di classi generiche sono condivise tra tutte le istanze della classe
  * le variabili e metodi statici di una classe generica non possono far riferimento ai parametri di tipo della classe accedendo ad un metodo statico di una classe generica il nome della classe non deve essere parametrizzato (con la variabile di tipo)

==== Esempio static ====
<code java>
public class Cella<T> { 
 private final int id; 
 private final T valore; 
 public static int count = 0;
 public static synchronized int getCount() { return count;} 
 public static synchronized int nextId() { return count++;} 
 public int getId() { return id; }
 public T getValore() { return valore;} 
 public Cella( T valore) { this.id = nextId(); this.valore = valore;}
...
</code>
Vediamo la classe all'opera
<code java>
Cella<String>cs = new Cella<String>("ciao");
Cella<Integer> ci = new Cella<Integer>(1);
assert cs.getId() == 0 && ci.getId() == 1
       && Cella.getCount() == 2;
</code>
Il contatore è condiviso tra tutte le istanze della classe Cella
==== Utilizzo di metodi static ====
  * Cella.getCount() OK
  * Cella<Integer>.getCount() NO 
  * Cella<?>.getCount() NO
===== Inner class =====

Java permette di annidare una classe dentro un'altra Se la classe esterna ha un parametro di tipo T:
  * Classe interna non statica → può accedere direttamente al parametro di tipo T
  * Classe interna statica→ non può accedere (direttamente) al parametro di tipo T //ma esiste un escamotage ...//
==== Inner class non statica ====
<code java>
public class Esterna<G> { ...
 private class Interna1{ 
  Gg =null; ...
 } ...
}
</code>
==== Inner class statica: escamotage ====
<code java>
public class Esterna<G> { ...
public G getPippo() { return new Interna2<G>().getPippo();
} public static class Interna2<H>{
public H getPippo() { ...
} ...
</code>