I tipi primitivi in Java sono:
Tipo Spazio occupato Numerici: byte 8 bit short 16 bit int 32 bit - sempre, a differenza del C long 64 bit float 32 bit double 64 bit Caratteri Unicode: char 16 bit Logici - true o false: boolean dipende dall'implementazioneI tipi numerici sono tutti con segno.
Tutti questi tipi primitivi possono essere "incapsulati" in degli oggetti
(vedi il prossimo capitolo), ad esempio un int
può essere incapsulato in un oggetto della classe Integer.
Esistono inoltre due classi, BigInteger e BigDecimal, che consentono di operare su numeri interi e decimali di precisione arbitraria - ovviamente con prestazioni di molto inferiori alle operazioni su tipi primitivi.
Una variabile in java può essere dichiarata in (quasi) qualsiasi punto, all'occorrenza:
for(int i = 0; i < 10; i++) ...Inoltre java, essendo più "intelligente" di altri linguaggi, non permette di nascondere variabili:
{
int i;
...
{
int i; // ERRORE - variabile gia' definita
...
}
}
Java 1.5 ha introdotto un nuovo ciclo for, simile al "foreach" di altri linguaggi. Ad esempio, se prima per stampare un array di 100 int si doveva scrivere:
for(int i = 0; i < 100; i++) System.out.println(array[i]);ora basta scrivere (":" si legge "in"):
for(int numero : array) System.out.println(numero);Nel capitolo sulle collezioni vedremo l'altro uso del nuovo for.
In java le stringhe sono oggetti di classe String, e sono trattate in modo speciale rispetto agli altri.
Ad esempio è possibile concatenare stringhe mediante gli operatori + e +=:
String s = ""; s += "ciao";Altro esempio:
String a = "Tizio", b = "Caio", c = "Sempronio"; System.out.println( a + ", " + b + " e " + c );
Inoltre tutte le classi sono dotate del metodo toString(), derivato da Object (vedi capitolo sull'ereditarietà), che fornisce una rappresentazione in forma di stringa dell'oggetto in questione.
Tale metodo viene chiamato (quasi) ogni volta ci sia bisogno di una stringa; ad esempio il codice:
Integer n = 5;
System.out.println("n vale " + n);
stampa "n vale 5" (notare uso autoboxing).
Da ciò si può vedere che il metodo printf, presente anche in
java nella classe java.io.PrintStream, può essere sostituito
dalla semplice concatenazione di stringhe, a meno che
non si desideri una formattazione particolare.
Un'altro tipo di oggetto molto particolare è l'array; ecco un esempio, la creazione di un array di 5 int, inizializzati a 0:
int[] numeri = new int[5];Si possono anche specificare gli elementi di un'array all'atto dell'allocazione; lo statement:
numeri = new int[] {1,55,36};
crea un'array di tre elementi, 1, 55 e 36.
Anche in java l'indice del primo elemento è 0,
quindi nell'ultimo esempio numeri[0] è 1.
Una differenza fondamentale con gli array del C è il controllo in
esecuzione dell'indice, quindi - sempre in riferimento all'ultimo esempio - il
codice che segue lancia una
ArrayIndexOutOfBoundsException:
numeri[3] = 6;Questo controllo può avere effetti negativi sulle prestazioni, ma il fatto di non rischiare più un buffer overflow - causa di molti problemi di sicurezza e stabilità - dovrebbe convincere tutti della bontà della sua adozione.
Quando in java si dichiara un oggetto, ad esempio con:
Long l;non si fa altro che dichiarare un riferimento - in pratica un puntatore, da usare però direttamente, "al posto" dell'oggetto. La creazione (allocazione) attuale dell'oggetto avviene con l'operatore new:
l = new Long(7);I tipi primitivi e le "reference" a oggetti vengono allocate sullo stack - come le variabili locali in C - mentre con new si creano oggetti e array sullo heap - come per le aree di memoria allocate con malloc in C.
E quando gli oggetti non servono più? Vengono abbandonati, riassegnando la/le reference a qualche altro oggetto o a null:
l = new Long(7*7); // il Long di valore 7 creato prima viene "abbandonato"Quando un oggetto non è più raggiungibile, ovvero quando nessuna reference "punta" ad esso, diventa inutile, spazzatura, e all'occorrenza può essere cancellato dalla garbage collection (gc), un meccanismo che si attiva ogni qualvolta la situazione della memoria lo richieda. La gc può anche essere avviata esplicitamente dal programma, con System.gc().
I commenti possono essere scritti su una o più linee, come in C/C++:
i++; // commento inutile
/* la seguente
funzione
bla, bla... */
public void do()
{
...
La novità sta nei commenti javadoc:
/** Rappresenta una persona. */
class Persona
{
...
/** Variabile importante. */
public double bigVar;
...
/** Calcola il minimo tra due numeri.
* @param n1,n2 i numeri da confrontare.
* @return il minimo tra n1 e n2.
*/
public int min(int n1, int n2)
{
...
Questi commenti, che iniziano con /**, possono essere estratti
dal sorgente mediante il tool javadoc, incluso nel JDK di Sun, per
produrre una documentazione nello stesso formato di quella delle API ufficiali;
è bene abituarsi a scriverli ogni volta che si ha a che fare con campi
particolarmente importanti e metodi non banali,
anche prima di scrivere il corpo della classe o del metodo.
All'interno di questi commenti è possibile usare tag HTML; ad esempio, per forzare un 'a capo' nel documento prodotto da javadoc si usa il tag <BR>.
In java è possibile l'overloading dei metodi, ovvero la scrittura per una stessa classe di più metodi con lo stesso nome, ma con diversa lista di argomenti, come:
public int max(int n1, int n2) { ... }
public float max(float n1, float n2) { ... }
Ciò che distingue i due metodi è solo la lista di argomenti,
non il tipo di ritorno.
Da java 5 è possibile dichiarare come ultimo parametro
di un metodo, liste di argomenti di lunghezza variabile;
ad esempio un metodo che calcola la media
di 0 (?) o più numeri di tipo float
può essere dichiarato così:
// '...' indica lunghezza variabile
public static float media(float... dati)
{
float res = 0f;
for(float num : dati)
res += num;
return res / dati.length;
}
e chiamato con un numero variabile di argomenti:
media(); // ritorna NaN, Not a Number media(23.2f, 45.3f, 6.9f); ...Dal codice del metodo si vede che
dati è a tutti gli effetti
un array.