Generics Java
Il JDK 1.5 ha introdotto alcune estensioni al linguaggio Java. Una di questa è l'introduzione dei generics o tipi generici. I generics permettono di definire delle astrazioni sui tipi di dati definiti nel linguaggio. L'esempio più comune del loro utilizzo è nella definizione/uso dei cosiddetti contenitori. Prima dell'uscita del JDK 1.5 per poter gestire in modo trasparente tipi di dati differenti si doveva ricorrere al fatto che in Java ogni classe deriva in modo implicito dalla classe Object. Per esempio se si doveva implementare una lista concatenata il codice era il seguente:
List myIntList = new LinkedList();
myIntList.add(new Integer(0));
e invece per recuperare l'elemento appena inserito si doveva scrivere
Integer x = (Integer) myIntList.iterator().next();
Si noti il cast a Integer necessario poiché myIntList in realtà lavora su oggetti Object. Dall'introduzione del JDK 1.5 invece è possibile utilizzare un codice come il seguente:
List<Integer> myIntList = new LinkedList<Integer>();
myIntList.add(new Integer(0));
dove viene esplicitamente espresso che la lista myIntList lavorerà solo su oggetti di tipo Integer. Per recuperare l'elemento appena inserito il codice è il seguente:
Integer x = myIntList.iterator().next();
Si noti che ora il cast non è più necessario visto che la lista è di interi.
Implementazione
Java 5 non ha esteso il linguaggio bytecode per implementare i generics. Questo vuol dire che i generics sono in realtà solo dei costrutti sintattici, emulati a livello di bytecode tramite il solito meccanismo della classe Object (descritto sopra).[1] Dichiarare
List<Integer> myIntList = new LinkedList<Integer>();
equivale a livello di codice a dichiarare
List myIntList = new LinkedList(); // Lista di Object
e ad eseguire implicitamente le conversioni Object->Integer e Integer->Object per leggere e scrivere gli elementi.
I generics hanno quindi eliminato i problemi riguardanti la tipizzazione; adesso gli elementi della lista devono essere Integer e non (per esempio) String e tale controllo è eseguito a tempo di compilazione.
Erasure
L' Erasure è il processo che converte il programma codificato con i generici nella forma senza di essi, che rispecchia più da vicino il bytecode prodotto. Questo termine non è del tutto corretto in quanto vengono si rimossi i generici, ma vengono anche aggiunti i cast. L'aggiunta di questi cast non è esplicita e il linguaggio di progetto fornisce la Casr-iron guarantee: ossia il cast implicito aggiunto alla compilazione dei generici.
Tipi parametrici varianti (Wildcard)
Non può esistere una compatibilità generale fra i tipi parametrici. Se si è alla ricerca della compatibilità, bisogna prendere in considerazione casi specifici e tipi di parametri di singoli metodi. Quindi, alla normale notazione dei tipi generici List<T>, usata per creare oggetti, si affianca una nuova notazione, pensata per esprimere i tipi accettabili come parametri in singoli metodi.
Si parla quindi di tipi parametrici varianti, in Java detti wildcard.
