Generics Java: differenze tra le versioni

Versione delle 17:27, 4 giu 2016

Versione attuale delle 13:08, 14 set 2024

(13 versioni intermedie di 10 utenti non mostrate)

Riga 1:

{{torna a|Java 5}}

Il [[Java 5|JDK 1.5]] ha introdotto alcune estensioni al [[Java (linguaggio di programmazione)|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 [[Astrazione (informatica)|astrazioni]] sui [[Tipo di dato|tipi di dati]] definiti nel linguaggio.

== Caratteristiche ==

Vi sono svariati vantaggi nell'uso dei generics:

*Fornisce una migliore gestione del '''[[Typetype check|type checking]]ing''' durante la compilazione;

*Evita il casting da ''Object. I.e.'';

*Evita errori dovuti a casting impropri

*Invece di utilizzare:

Invece di utilizzare (codice che potrebbe generare un errore di casting):

<source lang="java">

<sourcesyntaxhighlight lang="java">

String title=((String) words.get(i)).toUppercase();

</syntaxhighlight>

</source>

o più correttamente per evitare errori

<sourcesyntaxhighlight lang="java">

Object o=words.get(i);

String title="";

if(o instanceof String)

title=((String) o.get(i)).toUppercase();

</syntaxhighlight>

verrà utilizzato:

<sourcesyntaxhighlight lang="java">

String title=words.get(i).toUppercase();

</syntaxhighlight>

</source>

Vi sono però anche degli svantaggi:

*Si definisce:

*Si definisce:

<source lang="java">

List<String>words=new ArrayList<String>();

<syntaxhighlight lang="java">

</source>

List<String> words=new ArrayList<String>();

</syntaxhighlight>

invece di:

<sourcesyntaxhighlight lang="java">

List words=new ArrayList<String>();

</syntaxhighlight>

</source>

L'esempio più comune del loro utilizzo è nella definizione/uso dei cosiddetti ''[[container (informatica)|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 (informatica)|classe]] deriva in modo implicito dalla classe ''Object''. Per esempio se si doveva implementare una [[lista concatenata]] il codice era il seguente:

<sourcesyntaxhighlight lang="java">

List myIntList = new LinkedList();

myIntList.add(new Integer(0));

</syntaxhighlight>

</source>

e invece per recuperare l'elemento appena inserito si doveva scrivere

<sourcesyntaxhighlight lang="java">

Integer x = (Integer) myIntList.iterator().next();

</syntaxhighlight>

</source>

Si noti il [[Conversione di tipo|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:

<sourcesyntaxhighlight lang="java">

List<Integer> myIntList = new LinkedList<Integer>();

myIntList.add(new Integer(0));

</syntaxhighlight>

</source>

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:

<sourcesyntaxhighlight lang="java">

Integer x = myIntList.iterator().next();

</syntaxhighlight>

</source>

Si noti che ora il cast non è più necessario visto che la lista è di interi.

Line 64 ⟶ 74:

== 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).<ref>[http://www.artima.com/intv/generics2.html Generics in C#, Java, and C<!-- Titolo generato automaticamente -->]</ref> Dichiarare

<sourcesyntaxhighlight lang="java">

List<Integer> myIntList = new LinkedList<Integer>();

</syntaxhighlight>

</source>

equivale a livello di codice a dichiarare

<sourcesyntaxhighlight lang="java">

List myIntList = new LinkedList(); // Lista di Object

</syntaxhighlight>

</source>

e ad eseguire implicitamente le conversioni ''Object->Integer'' e ''Integer->Object'' per leggere e scrivere gli elementi.

Line 76 ⟶ 86:

== 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 sisì rimossi i generici, ma vengono anche aggiunti i cast.

L'aggiunta di questi cast non è esplicita e il linguaggio di progetto fornisce la '''Cast-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:

Line 90 ⟶ 100:

Per verificarlo, creiamo due liste:

<sourcesyntaxhighlight lang="java">

LinkedList<Number> l1 = new LinkedList<Number>();

LinkedList<Integer> l2 = new LinkedList<Integer>();

</sourcesyntaxhighlight>

E consideriamo i due possibili assegnamenti l1 = l2 e l2 = l1; si

Line 101 ⟶ 111:

Gli assegnamenti in precedenza sono impossibili perché viene violato '''il principio di sostituzione''': Ad una variabile di un certo tipo può essere assegnato un valore di ogni sottotipo; un metodo con un argomento di un certo tipo può essere chiamato con un argomento di ogni sottotipo.

<sourcesyntaxhighlight lang="java">

List<Number> numbers = new ArrayList<Number>();

numbers.add(2);

numbers.add(3.14d);

assert numbers.toString().equals("[2, 3.14]");

</sourcesyntaxhighlight>

Qui il principio vale fra ''List'' e ''ArrayList'' e fra ''Number'' e ''Integer Double'' in maniera rispettiva.

''List<Integer>'' invece '''non è un sottotipo''' di ''List<Number>'' in quanto viene violato nuovamente '''il principio di sostituzione''', ad esempio:

<sourcesyntaxhighlight lang="java">

List<Integer> integers = Arrays.asList(1, 2);

List<Number> numbers = integers; // non compila

numbers.add(3.14d);

assert integers.toString().equals("[1, 2,3.14]");

</sourcesyntaxhighlight>

== 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 (linguaggio di programmazione)|Java]] detti '''wildcard'''.

Posto che la notazione ''List<T>'' denota il normale tipo generico, si introducono le seguenti '''notazioni wildcard''':

*tipo '''covariante''' ''List<? extends T>'': cattura le proprietà dei ''List<X>'' in cui ''X'' estende ''T''; si usa per specificare tipi che possono essere solo letti.

*tipo '''controvariante''' ''List<? super T>'': cattura le proprietà dei ''List<X>'' in cui ''X'' è esteso da ''T''; si usa per specificare tipi che possono essere solo scritti.

*tipo '''bivariante''' ''List<?>'': cattura tutti i ''List<T>'' senza distinzioni; si usa per specificare i tipi che ''non'' consentono né letture né scritture.

== Definizione di una classe generica ==

Ecco un esempio di classe generics

<sourcesyntaxhighlight lang="java">

public class Gen<X,Y> {

Line 152 ⟶ 162:

}

}

</sourcesyntaxhighlight>

Questa classe non serve a nulla da sola, deve essere quindi utilizzata un'altra struttura, come nell'esempio successivo:

<sourcesyntaxhighlight lang="java">

Gen<String, String> esempio1 = new Gen<String, String>("esempio", "uno");

Line 164 ⟶ 174:

System.out.println("secondo esempio: " + esempio2);

</sourcesyntaxhighlight>

==Note==