Generics Java
Il JDK 1.5 ha introdotto alcune estensioni al linguaggio Java. Una di questa è l'introduzione dei generics o tipi generici. Un generics è uno strumento che permette la definizione di un tipo parametrizzato, che viene esplicitato successivamente in fase di compilazione secondo le necessità; i generics permettono di definire delle astrazioni sui tipi di dati definiti nel linguaggio.
Vi sono svariati vantaggi nell'uso dei generics:
- Fornisce una migliore gestione del type checking durante la compilazione;
- Evita il casting da Object. I.e.;
- Invece di utilizzare:
String title=((String) words.get(i)).toUppercase();
verrà utilizzato:
String title=words.get(i).toUppercase();
Vi sono però anche degli svantaggi:
- Si definisce:
List<String>words=new ArrayList<String>();
invece di:
List words=new ArrayList<String>();
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: non può mai fallire. Questa è una regola che si applica per il codice che non presenta unchecked warnings. I vantaggi dell'implementazione via Erasure, sono:
- mantenere le cose semplici senza aggiunta di dettagli o altro;
- mantenere le cose piccole ad esempio con una sola implementazione di List;
- semplificare l'evoluzione, la stessa libreria può essere accessibile da un codice generico e da codici legacy.
Se un elemento Y deriva da un elemento X, non si può dire che una collezione di elementi di Y derivi dalla collezione di elementi X, perché in generale ciò risulta un'operazione impossibile; solo alcune di questo potrebbero essere anche sicuri, soprattutto per ciò che riguarda gli array e la lettura, ma ciò non è vero in generale.
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.
