Una variabile array contiene un riferimento

L'oggetto contenuto potrebbe non essere stato ancora creato.

Per poterlo utilizzare occorre creare l'array.

Se l'oggetto array non è stato creato il riferimento è nullo

Vediamo adesso come creare una schiera. La cosa importante da ricordare è il fatto che una schiera è un oggetto tutti gli effetti. Quindi valgono le regole vistre prima, e una variabile di tipo schiera contiene solamente un riferimento ad un oggetto. L'oggetto in questione potrebbe non esistere: infatti per poter usare una schiera devo creare l'istanza della schiara. Se provo a usare una schiera senza averla creata, ho una sgradita sorpresa: ottengo una eccezione. Vediamo un caso pratico:

int[] ax; 
ax[2]; 
// NullPointerException!

In questo esempio ho solo dichiarato la variabile ma non ho creato l'oggetto contenuto, per cui la risposta dell'interprete è quella che ci può aspettare: una eccezione di puntatore nullo. Fare attenzione che queste eccezione scatta ogniqualvolta si cerca di utilizzare il riferimento nullo per accedere a un oggetto che non c'è. Nell'esempio che stiamo, vedendo l'oggetto che manca è proprio schiera.

Sintassi per la costruzione di array:

Una volta constatato che la schiera va sempre creata, vediamo come fare a crearla, in particolare vediamo la sintassi della creazione.

costruito con new e il numero di elementi

Il modo più immediato è quello di utilizzare l'operatore new. La sintassi richiede che venga utilizzato in questo caso il nome della classe, seguito dal numero di elementi che saranno contenuti nella schiera. Il difetto di questo sistema è che lascia tutte le variabili della schiera non inizializzate. Cioè in questo modo esiste la schiera ma possono non esistere gli elementi della schiera. In realtà questo dipende dal fatto che gli elementi siano tipi primitivi oppure oggetti. Se si tratta di tipi primitivi, creare la schiara crea automanticamente lo spazio per contenere gli elementi. Se invece si tratta di classi, la schiera contiene solo i riferimenti ad oggetti che dovranno essere creati e poi assegnati ai vari elementi.

elencando tra graffe i valori di inizializzazione

// un array di tre interi
int[] ai = new int[3];

// un array di tre interi
int[] ai = { 0, 1, 2 } 
//a[0]==0, a[1]==1, a[2]==2

L'altra sintassi prevede che vengano scritte tra parentesti graffe tutti gli elementi della schiera. Innanzitutto, non occorre specificare il numero di elementi. Questo numero viene calcolato automaticamente dal compilatore, contando gli elementi posti tra parentesi graffe.L'altro importante caratteristica di questa sintassi è che consente di creare anche di inizializzare i vari elementi della schiera, creando eventualmente gli oggetti mancanti in una schiera di una classe.

Differenze tra le due sintassi

a

Con new, un nuovo array di tipi primitivi esiste ed è usabile

Con new, un nuovo array di tipi derivati contiene solo riferimenti nulli

Con le graffe, un nuovo array anche di oggetti è completo

01. Stack[] as = new Stack[3];
02. Stack t = as[2];  
03. //ok
04. as[2].push()     
05. //NullPointerException
06. Stack[] bs = { 
07.   new Stack(), new Stack(), new Stack() 
08. };
09. bs[2].push()    
10.// ok

Vediamo meglio queste caratterische esaminando il listato. Nella riga 1 abbiamo creato un nuovo array di Stack. La schiera c'è, e quindi in riga 2 non ottengo errore. Ma la cosa importante è che non c'è uno stack nel secondo elemento. La schiera appena creata contiene solo puntatori nulli. Per cui se tento di invocare un metodo su as[2] il risultato è NullPointerException. Le cose vanno meglio se creo l'array con l'altra sintassi e mi preoccupo anche di creare i vari elementi contenuti nella schiera. Come si vede il risultato è quello che ci si può aspettare, la schiera ha tre elementi e ognuno degli elementi è stato inizializzato correttamente, per cui è nella riga 9 non abbiamo la sorpresa della riga 2.