Java 5

Da Wikipedia, l'enciclopedia libera.
Logo Java

Java 5 è la versione 5.0 dell'edizione standard del linguaggio di programmazione Java (in inglese Java 2 Platform Standard Edition o J2SE). Questa versione era inizialmente conosciuta come versione 1.5.0, ma i creatori del linguaggio, per enfatizzarne il livello di maturità e stabilità raggiunto, hanno preferito rinominarla eliminando l'uno iniziale[1]. Il nome in codice di Java 5 durante lo sviluppo era Tiger.

Questa versione è stata pubblicata per la prima volta il 29 settembre 2004 e contiene nuove funzionalità che puntano a semplificare e potenziare il linguaggio stesso. Il codice bytecode prodotto da un compilatore Java 5 può essere eseguito su qualsiasi macchina virtuale Java. Per usufruire quindi delle nuove caratteristiche del linguaggio non è necessario aggiornare la macchina virtuale.

Le nuove caratteristiche del linguaggio hanno permesso di potenziare e semplificare altre componenti standard di Java. Ad esempio gli Enterprise JavaBeans, che fanno parte delle specifiche dell'edizione enterprise di Java, erano noti agli sviluppatori per essere particolarmente complessi da programmare, ma dalla versione 3.0 questo problema è stato risolto grazie all'utilizzo dei metadati.

Modifiche al linguaggio[modifica | modifica wikitesto]

Numero variabile di argomenti[modifica | modifica wikitesto]

È possibile definire metodi in grado di avere in input un numero qualsiasi di argomenti dello stesso tipo. Utilizzando gli Array si è in grado di ottenere la stessa funzionalità con le versioni precedenti alla 1.5; tuttavia l'utilizzo di una sintassi specifica rende più semplice e leggibile questo tipo di codice.

A titolo di esempio il seguente codice utilizza esclusivamente funzionalità della versione 1.4 di Java:

 public static void fai_qualcosa(String args[]) {
    for (int i=0;i <args.length; i++) {
      //fai qualcosa
    }
 }
 //...
    fai_qualcosa(new String[] { "Questo è", " un set di parametri", " passati..." } );
    fai_qualcosa(new String[] { "Questo è", " un set di parametri", " passati...", " alla funzione" } );

Quindi, in pratica, il metodo viene definito in modo che accetti come parametro un array, il quale viene poi inizializzato quando il metodo stesso viene richiamato.

Con Java 1.5, lo stesso risultato può essere ottenuto con il seguente codice:

 public static void fai_qualcosa(String ... args) {
    for (int i=0;i <args.length; i++) {
      //fai qualcosa
    }
 }
 //...
    fai_qualcosa("Questo è", " un set di parametri", " passati...");
    fai_qualcosa("Questo è", " un set di parametri", " passati...", " alla funzione");

Output formattato[modifica | modifica wikitesto]

È stata aggiunta alla classe System la funzione printf che permette una formattazione dell'output simile all'omonima funzione del linguaggio C.

 public static void main(String ... s)
 {
    System.out.printf("Hai passato %s e %s, in totale %d parametri\n",s[0],s[1],2);
 }

La funzione printf ha il seguente prototipo:

 public static void printf(String s, Object ... objs);

Tipi generici[modifica | modifica wikitesto]

Exquisite-kfind.png Lo stesso argomento in dettaglio: Generics Java.

I tipi generici o generics permettono di semplificare l'utilizzo di classi che, come ad esempio le classi del package Collection, gestiscono collezioni di oggetti di qualsiasi tipo. Senza l'uso dei tipi generici, la gestione di oggetti di qualsiasi tipo può essere effettuata convertendo preventivamente gli oggetti nel tipo Object, che è la classe da cui derivano tutte le altre. Questa soluzione obbliga il programmatore a utilizzare operazioni di conversione di tipo (casting) ogniqualvolta è necessario prelevare un oggetto dalla collezione; inoltre non è possibile controllare a tempo di compilazione se vi siano errori di conversione di tipo, ad esempio se viene aggiunto alla collezione un tipo di oggetto non valido.

I tipi generici risolvono entrambi questi problemi, ad esempio il seguente codice utilizza esclusivamente le funzionalità di Java 1.4 per aggiungere e successivamente prelevare due stringhe da una collezione di tipo ArrayList :

 List lista = new ArrayList();
 lista.add("stringa1");
 lista.add("stringa2");
 String s1 = (String)lista.get(0);
 StringBuffer s2 = (StringBuffer)lista.get(1);

Con Java 1.5 lo stesso codice può essere scritto nel modo seguente:

 List<String> lista = new ArrayList<String>();
 lista.add("stringa1");
 lista.add("stringa2");
 String s1 = lista.get(0);
 StringBuffer s2 = lista.get(1);

In entrambe le versioni vi è un errore di tipo in quanto la variabile s2 non è dichiarata di tipo String (né di una superclasse di String). Tuttavia nella versione 1.4 il codice viene compilato e l'errore viene individuato solo a tempo di esecuzione, mentre con la versione 1.5 l'errore è individuato a tempo di compilazione perché si è dichiarata la variabile lista come una collezione di oggetti di tipo String.

Metadati[modifica | modifica wikitesto]

I metadati permettono di associare informazioni aggiuntive alle classi, alle interfacce, ai metodi e ai campi di un programma Java. Queste informazioni aggiuntive, dette anche annotazioni, possono essere lette e processate sia dal compilatore Java che da altri strumenti, e possono essere memorizzate nei file.class prodotti dal compilatore per essere poi lette a tempo di esecuzione tramite le apposite funzioni di introspezione messe a disposizione dal linguaggio.

I metadati, in combinazione con strumenti in grado di elabolarli, possono rendere molto più concisa la sintassi di un programma Java. Ad esempio, per definire i metodi remoti di una classe senza usufruire dei metadati sarebbe necessario scrivere un codice simile al seguente:

  public interface PingIF extends Remote {
      public void ping() throws RemoteException;
  }
  public class Ping implements PingIF {
     public void ping() {
     }
  }

con i metadati si può ottenere un risultato analogo con un codice molto più semplice e leggibile:

  public class Ping {
     public @remote void ping() {
     }
  }

Autoboxing[modifica | modifica wikitesto]

L'autoboxing permette di fare una conversione di tipo automatica tra un tipo primitivo e la sua classe equivalente. Ad esempio nel codice seguente viene effettuata una conversione automatica della variabile i dal tipo primitivo int al tipo Integer, e il valore risultante viene assegnato alla variabile i_oggetto:

 int i = 42;
 Integer i_oggetto = i;
 System.out.println(i_oggetto);

Anche questa modifica va nella direzione di una maggiore leggibilità del codice, in quanto elimina la necessità di effettuare una esplicita conversione di tipo.

Ciclo for migliorato (ciclo foreach)[modifica | modifica wikitesto]

Il ciclo for è stato migliorato in modo da eliminare la necessità dell'uso degli iteratori, fornendo così una sintassi più semplice e meno soggetta ad errori. Ad esempio, il seguente è un frammento di codice Java 1.4:

 int[] iss = new int[] {1,2,3,4,5} ;
 for(int i = 0; i < iss.length; i++) 
 {
    list.add(new Integer(iss[i]));
    //...
 }

 List list = new ArrayList();
 for(Iterator it = list.iterator(); it.hasNext();) 
 {
    doStuff((Integer)x);
    //...
 }

Nella versione 1.5 lo stesso codice può essere scritto nel modo seguente:

 int[] iss = new int[] {1,2,3,4,5} ;
 for(int x : iss) 
 {
    list.add(x);
    //...
 }

 List<Integer> list = new ArrayList<Integer>();
 for(Integer x : list) 
 {
    doStuff(x);
    //...
 }

Tipo enumerazione[modifica | modifica wikitesto]

Il tipo enumerazione permette di definire una serie di valori costanti, senza dover esplicitamente assegnare ad ognuno di essi un corrispondente valore numerico. Ad esempio, in Java 1.4 una enumerazione può essere definita nel modo seguente:

  public static final int ROSSO  = 0;
  public static final int VERDE  = 1;
  public static final int GIALLO = 2;
  public static final int BLUE   = 3;

In Java 1.5 si può utilizzare la parola chiave enum per definire lo stesso tipo di valori:

 public enum Colori { ROSSO, VERDE, GIALLO, BLUE};

Importazione delle costanti statiche[modifica | modifica wikitesto]

L'importazione delle costanti statiche permette di fare uso di costanti statiche di una classe o di una interfaccia senza il bisogno di dover derivare da quella classe o implementare quell'interfaccia. Per eseguire questo tipo di importazione si usa la parola chiave import static, ad esempio:

 import static java.awt.BorderLayout.*;

Note[modifica | modifica wikitesto]

  1. ^ (EN) http://java.sun.com/j2se/1.5.0/docs/relnotes/version-5.0.html Motivazioni per il cambiamento del numero di versione.

Voci correlate[modifica | modifica wikitesto]

Collegamenti esterni[modifica | modifica wikitesto]

Informatica Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica