2. IL LINGUAGGIO JAVA

Transcript

1 IL LINGUAGGIO JAVA Dispense per il corso di laboratorio di sistemi I.T.I.S. ABACUS A.S. 2008/2009 Autore: Roberto Amadini Testo di riferimento: La programmazione ad oggetti C++ Java (Lorenzi, Moriggia, Rizzi ATLAS) 2. IL LINGUAGGIO JAVA 2.1 Introduzione Java è un linguaggio di programmazione ad alto livello orientato agli oggetti. Il processo di sviluppo di Java cominciò agli inizi degli anni 90 da un gruppo di ingegneri della Sun Microsystems, mentre la sua prima apparizione ufficiale avvenne nel maggio del Le principali caratteristiche di Java sono: L orientamento agli oggetti La portabilità delle sue applicazioni La possibilità di costruire GUI (Graphical User Interface) La gestione di multithreading e networking L ORIENTAMENTO AGLI OGGETTI consiste nella presenza di costrutti che implementano concetti propri della OOP come ereditarietà, polimorfismo, incapsulamento, gestione delle eccezioni ecc Java è un linguaggio OO di tipo ibrido in quanto prevede la possibilità di gestire tipi di dato primitivi oltre agli oggetti (ad esempio int, char, float, double ecc ). Tuttavia spesso Java viene considerato come linguaggio puro in quanto gli oggetti costituiscono la struttura portante del linguaggio, mentre i tipi primitivi ne rappresentano solo una parte marginale. Di fatto questo linguaggio deriva direttamente dal C++, per cui molte caratteristiche di Java sono del tutto simili (se non addirittura identiche) al C++. Le maggiori differenze a livello di programmazione tra Java e C++ riguardano: L EREDITARIETA : In Java si utilizza solamente l ereditarietà SINGOLA (cioè una sottoclasse può avere al massimo una classe padre) mentre il C++ permette l ereditarietà MULTIPLA (una sottoclasse può derivare da più classi padre). In realtà anche Java implementa un concetto simile all ereditarietà multipla, grazie all ausilio di classi interfaccia (interfaces) opportunamente implementate (implements). La gestione della MEMORIA DINAMICA: In Java, fatta eccezione per i tipi primitivi, ogni variabile (array e oggetti) è di tipo riferimento (reference): le variabili contengono cioè un riferimento all indirizzo di memoria dove sono allocati i dati (e i metodi) contenuti dalle variabili. Al contrario del C++, non è possibile utilizzare esplicitamente i puntatori per manipolare l allocazione e la de-allocazione dinamica di oggetti in memoria; in particolare la de-allocazione è gestita in modo automatico dal sistema di run-time mediante un apposito strumento chiamato garbage collector (letteralmente raccoglitore di rifiuti, si occupa di ripulire la memoria).

2 La forte TIPIZZAZIONE: In Java le conversioni di tipo (cast) devono essere tutte esplicitate (al contrario il C++ permette in taluni casi conversioni non esplicitate). Fanno eccezione le promozioni di tipo (conversioni senza perdita di dati, ad esempio da int a float). La PORTABILITA è una proprietà fondamentale di Java; essa consiste nella capacità di poter eseguire codice Java su qualsiasi piattaforma in modo indipendente dall hardware e dal sistema operativo sul quale il programma è in esecuzione. La portabilità in Java è realizzata con un sistema misto di compilazione/interpretazione: Il codice sorgente (estensione.java) viene compilato dal compilatore di java (comando javac) che trasforma il codice sorgente in un apposito codice detto BYTECODE (estensione.class) Il bytecode non può essere eseguito da una macchina reale ma solamente da una macchina virtuale: la JAVA VIRTUAL MACHINE (JVM). La JVM è uno strato software che si pone sopra la macchina fisica dove è in esecuzione il file; il suo compito consiste nel permettere l esecuzione del bytecode anche sulla macchina fisica interpretando ogni sua riga, cioè traducendo il bytecode (comprensibile solo dalla JVM) in codice macchina eseguibile sulla particolare macchina fisica (comando java). In questo modo, posso eseguire un file.class di java su qualsiasi piattaforma senza bisogno di dover modificare e/o ricompilare il codice sorgente: la JVM della particolare macchina fisica si occuperà del processo di interpretazione. CODICE SORGENTE COMPILAZIONE BYTECODE INTERPRETAZIONE JVM MACCHINA FISICA MioFile.java javac MioFile.Java MioFile.class java MioFile Eseguo MioFile Questa soluzione tuttavia è poco efficiente, in quanto l interpretazione ha tempi decisamente maggiori rispetto alla compilazione. Per questo motivo, tutte le implementazioni recenti di JVM hanno incorporato un compilatore just-in-time (JIT compiler), cioè un compilatore interno, che al momento del lancio traduce al volo il programma bytecode Java in un normale programma nel linguaggio macchina del computer ospite (cioè anziché compilare il sorgente ed interpretare il corrispondente bytecode, di fatto compilo il sorgente e poi grazie al JIT ri-compilo il corrispondente byte code). Questi accorgimenti, a prezzo di una piccola attesa in fase di lancio del programma, permettono di avere delle applicazioni Java decisamente più veloci e leggere. Tuttavia, anche così Java resta un linguaggio meno efficiente dei linguaggi compilati come il C++, scontando il fatto di possedere degli strati di astrazione in più (la JVM) e di implementare una serie di automatismi, come il garbage collector, che se da un lato fanno risparmiare tempo ed errori in fase di sviluppo dei programmi, dall'altro sprecano spazio di memoria e tempo di CPU in fase di esecuzione del programma.

3 Per poter programmare ed eseguire codice Java gli strumenti necessari sono: Un EDITOR di testo per scrivere il codice (ad es. Blocco note, emacs ) Un COMPILATORE (javac) ed un INTERPRETE java (java). Tali strumenti fanno parte del JDK (Java Development Kit), che comprende inoltre altre funzionalità per lo sviluppo di codice java (ad es., strumenti per la documentazione automatica del codice). Ad ogni JDK si associa quindi una JVM per la traduzione del bytecode e un JRE (Java Run-Time Environment) che permette l esecuzione effettiva delle applicazioni Java sulla macchina fisica. Esistono tuttavia AMBIENTI INTEGRATI (IDE, Integrated Development Environment) che integrano Editor, JDK, JVM e JRE. Tra i più diffusi attualmente citiamo NetBeans ed Eclipse. 2.2 La struttura di un programma Java In Java, a differenza del C++, un applicazione può essere costituita da una o più classi. Tra tutte le classi che compongono un applicazione Java, una si differenzia dalle altre perché: Ha lo stesso nome del file sorgente che contiene la classe Contiene lo speciale metodo main. Questo metodo è fondamentale perché l esecuzione dell applicazione Java comincia a partire da questo metodo. Vediamo quindi lo scheletro di un generico programma prova.java costituito da una sola classe: /* Importo le librerie (package) necessarie */ import Package_1;... import Package_n; /* Classe principale, contiene il main e deve avere lo stesso nome del file sorgente. */ class prova { /* Metodo principale, necessario per l esecuzione */ public static void main(string args[]) { // dichiarazione variabili // istruzioni del programma } // fine main } // fine classe nomefile

4 I package Java I package di Java sono insiemi di classi che forniscono servizi simili. Ogni utente può creare un proprio package oppure importare un package pre-esistente. I package di base di java (J2SE 6.0) sono: java.lang funzionalità di base del linguaggio e tipi di dato fondamentali java.util classi di collezione (strutture dati quali Vector, Stack, List, ecc ) java.io, java.nio operazioni si input/output java.math operazioni aritmetiche in multi precisione java.net operazioni di networking java.security gestione di sicurezza e crittografia java.sql operazioni su basi di dati java.awt, java.swing gestione di interfaccie GUI Per importare un package predefinito si usa l istruzione import nomepackage; in questo modo sarà possibile utilizzare tutte le funzionalità del package specificato. Di fatto quest istruzione corrisponde alla direttiva di pre-processing #include che è possibile utilizzare in C++ per includere librerie o file esterni al sorgente. 2.3 Il metodo main Come per il C++, il metodo main è fondamentale per il programma, in quanto da esso parte l esecuzione del codice. A differenza del C++, nel quale il main è una funzione, in Java il main è un metodo: in sostanza è una funzione propria della classe che lo contiene (nel nostro esempio la classe prova, che deve necessariamente avere lo stesso nome del sorgente in cui è contenuta: prova.java). In Java infatti non esistono funzioni (al contrario del C++, essendo tale linguaggio fortemente legato al linguaggio procedurale C) ma solamente metodi: ogni funzione quindi deve appartenere ad una certa classe. Per questo motivo Java viene spesso considerato linguaggio object-oriented puro. Nell esempio inoltre il metodo main è preceduto da tre parole-chiave: public indica che il metodo è pubblico, cioè visibile ed accessibile da chiunque. static indica che il metodo è statico, cioè associato alla classe in cui è contenuto (prova) e non ad oggetti della classe. Per ora ci basti sapere solo questo void indica che non ritorna nulla (esattamente come in C++) Inoltre, il main possiede anche un parametro: String args[] Come si può intuire, tale parametro è un array di stringhe, che corrisponde ai parametri passati da riga di comando quando l applicazione viene lanciata. Basandoci su quanto appena visto, scriviamo ora il nostro primo programma in Java:

5 /* Questo semplice programma legge una stringa da riga di comando e la stampa a video. Non importo nessuna libreria, in quanto il programma non lo richiede (non utilizzo costrutti particolari) */ class primoprog { public static void main(string args[]) { String stringaletta = args[0]; System.out.println( Hai inserito la stringa: + stringaletta); } // fine main } // fine classe primoprog Innanzitutto si noti che la sintassi e la semantica dei commenti ( /* */ e // ) è identica al C++. Inoltre è importante sottolineare che come il C++ anche Java è case-sensitive: non è indifferente utilizzare le maiuscole anziché le minuscole e viceversa. Il sorgente java si chiamerà primoprog.java (stesso nome della classe contenente il main). Il nostro programma per prima cosa dichiara una variabile di tipo String (stringa di caratteri, cfr. tipo string in C++) di nome stringaletta che inizializza con il valore di args[0]. Cosa significa? In pratica, quando l utente da riga di comando esegue il programma, può aggiungere uno o più parametri di tipo stringa che vengono automaticamente inseriti nell array args. Quindi, all interno del main è possibile estrarre tali parametri; nel nostro esempio estraggo il valore di args[0](che corrisponderà al primo parametro inserito) e lo inserisco nella variabile stringaletta. Dopodiché, stampo a video un messaggio contenente il valore di stringaletta. Per fare ciò utilizzo il metodo println della classe System.out che permette di stampare su standard output (il video) tale messaggio. Ciò è l equivalente del cout in C++; si noti tuttavia il mancato utilizzo dell operatore <<: la concatenazione delle stringhe Hai inserito la stringa: e stringaletta avviene mediante l operatore +. Vediamo ora come è possibile eseguire il nostro primo programma primoprog.java Per scrivere il programma è sufficiente un qualsiasi editor di testo (ad es. Blocco note); ovviamente bisogna ricordarsi di salvare il file con l estensione.java Una volta scritto, il programma va compilato: apriamo quindi il prompt dei comandi di MS-DOS e, dopo esserci posizionati nella cartella dove è presente il file primoprog.java, digitiamo: javac primoprog.java A questo punto, se non ci sono errori, viene generato il bytecode del sorgente: primoprog.class Ora per eseguire il programma è sufficiente richiamare l interprete Java che trasforma il bytecode in linguaggio macchina: java primoprog

6 Il programma verrà quindi eseguito, stampando a video il messaggio: Hai inserito la stringa: Perché? Semplicemente perché non abbiamo inserito alcun parametro da riga di comando! Se invece provassimo a digitare (senza dover ricompilare!) java primoprog Ciao!!! Allora l output del programma sarà: Hai inserito la stringa: Ciao!!! In questo caso infatti args[0]conterrà la stringa Ciao!!! E se invece scrivessimo da riga di comando: java primoprog Ciao mondo!!! In questo caso l output sarà: Hai inserito la stringa: Ciao Questo perché i parametri passati da riga di comando sono due: Ciao e mondo!!! Tali parametri verranno quindi inseriti rispettivamente in args[0] e args[1], ma siccome il programma stampa solamente il primo parametro (Ciao), il secondo (mondo!!!) viene ignorato. 2.3 Gli identificatori Gli identificatori sono nomi (sequenze di lettere e numeri) che possono essere attribuiti a variabili, metodi, classi ed oggetti. Come per il C++ non tutti gli identificatori sono formalmente corretti: esistono delle regole ben precise (ad es. devono cominciare con una lettera, non possono contenere caratteri speciali, devono avere una lunghezza massima, ecc ). In particolare, un identificatore non può chiamarsi come una parola-chiave di Java, in quanto tali parole sono riservate per particolari scopi. Le parole-chiave di Java sono ad oggi (J2SE 6.0) cinquanta: abstract continue for new switch assert default goto package synchronized boolean do if private this break double implements protected throw byte else import public throws case enum instanceof return transient catch extends int short try char final interface static void class finally long strictfp volatile const float native super while Le celle evidenziate sono parole chiave anche del C++.

7 2.4 Variabili, costanti e tipi di dato La sintassi e la semantica delle variabili è molto simile al C++; una variabile è caratterizzata da un nome, un tipo, un valore e dalla sua visibilità (scope). Ad esempio: int num; float altezza = 1.68; boolean x = true; //equivalente al tipo bool in C++ byte temperatura; //intero a 8 byte (può contenere valori da -128 a 127) Come nel C++ esistono regole di scope per le variabili. In sintesi una variabile è visibile all interno del blocco in cui è dichiarata ed invisibile all esterno del blocco; inoltre a differenza del C++ non è possibile dichiarare variabili con lo stesso nome all interno di blocchi annidati, cioè non è possibile avere una situazione di questo tipo: { int x;... { int x; //ri-dichiarazione di x: NON PERMESSO IN JAVA!... } //blocco interno } //blocco esterno Una costante è una variabile che deve assumere sempre lo stesso valore per tutta la durata del programma; in Java anziché la parola chiave const si utilizza final, ad esempio: final double PI_GRECO = 3.14; Tipicamente in Java le variabili sono scritte sempre in minuscolo, mentre la maiuscola viene usata al posto dello spazio (ad es. numeropersone, minimocomunemultiplo, valoreassoluto). Al contrario, le costanti sono scritte in maiuscolo, mentre al posto dello spazio si usa il carattere di underscore (ad es. TEMP_MAX, NUM_DI_NEPERO, ALIQUOTA_IVA). I tipi di dato in Java si suddividono in: tipi primitivi: byte, short, int, long, float, double, char, boolean. tipi riferimento: sono gli array e le classi, ce ne occuperemo più avanti. I tipi primitivi sono gli stessi del C++ a differenza di boolean e byte; in Java tuttavia non esistono i numeri unsigned (cioè senza segno, sempre positivi). La differenza fondamentale col C++ sta nella forte tipizzazione di Java: le conversioni (cast) tra tipi diversi devono essere quasi sempre esplicitate (fanno eccezione per le promozioni di tipo, cioè conversioni senza perdita di dati, ad es. int float, byte double ecc ):

8 float pigreco = 3.14; int pg = pigreco; //errore di compilazione! Le precedenti istruzioni generano un errore a tempo di compilazione in quanto sto convertendo una variabile float in una variabile int (ho una perdita di dati, perciò non ho una promozione) senza avere esplicitato il cast. La versione corretta dell assegnamento è quindi: float pigreco = 3.14; int pg = (int) pigreco; //converto pigreco nell intero pg: pg = Operatori logici e matematici Anche in questo caso la sintassi e la semantica è molto simile al C++; gli operatori utilizzati da Java sono: = > <! ~?: == <= >=!= && ++ + * / & ^ % << >> >>> += = *= /= &= = ^= %= <<= >>= >>>= Le celle evidenziate sono quelle di maggior interesse per i nostri scopi Vale la pena ricordare che gli operatori non evidenziati in tabella servono per operazioni bit-a-bit (bit-wise) tra numeri binari. Ad esempio, << e >> in Java non servono per l input/output ma per shiftare bit a sinistra e a destra; ~ calcola il complemento ad uno, ^ l or esclusivo (XOR). 2.6 La gestione dell input/output Abbiamo già visto nel programma precedente un esempio di scrittura in output: System.out.println( Hai inserito la stringa: + stringaletta); System.out è un oggetto associato allo standard output (video); viene quindi richiamato il metodo println di tale classe per poter stampare il parametro contenuto tra parentesi (due stringhe di testo concatenate in questo caso)e poi andare a capo. Tale parametro può essere tuttavia anche un numero intero o reale, un carattere o un booleano. L oggetto System.out possiede inoltre altri metodi; ad esempio il metodo print(x) stampa il valore di x senza poi andare a capo. Analogamente a System.out esistono gli oggetti System.err (associato allo standard error, il video) e System.in (associato allo standard input, tastiera). Tuttavia l utilizzo diretto di quest ultimo non è conveniente; si preferisce quindi combinarlo con oggetti più potenti quali InputStreamReader e BufferedReader nel seguente modo:

9 InputStreamReader input = new InputStreamReader(System.in); BufferedReader tastiera = new BufferedReader(input); Con queste istruzioni definisco prima un oggetto input di classe inizializzato con System.in; quindi creo un altro oggetto tastiera di classe BufferedReader inizializzato con input. Questo mi serve per sfruttare al meglio le potenzialità della classe BufferedReader ; ad esempio il metodo readline() di tale classe permette di leggere da standard input una riga per volta. Attenzione! Il metodo readline() accetta solo stringhe: se si vogliono acquisire altri tipi di dato, occorre fare il casting. Inoltre, tale metodo deve poter gestire eventuali eccezioni. Un eccezione è una situazione anomala che si verifica durante l esecuzione del programma, come ad esempio una divisione per zero. La gestione delle eccezioni verrà ripreso più avanti; per ora ci basti sapere che la lettura di un dato da tastiera deve avvenite all interno di un apposito blocco try-catch. Vediamo un esempio: InputStreamReader input = new InputStreamReader(System.in); BufferedReader tastiera = new BufferedReader(input); String nome; System.out.println( Come ti chiami? ); try { nome = tastiera.readline(); } catch(exception e) {} In questo caso il programma chiede semplicemente all utente il proprio nome da standard input e lo legge nella variabile tastiera. L istruzione di lettura readline deve sempre essere compresa in un blocco try seguito da un blocco catch (anche vuoto, come in questo caso). Esempio: Scrivere un programma Java che chieda all utente il proprio anno di nascita e, successivamente, gli comunichi se è nato in un anno bisestile oppure no.

10 /* Questo programma chiede all utente il proprio anno di nascita e, successivamente, gli comunica se è nato in un anno bisestile oppure no. */ class esbisestile { public static void main(string args[]) { InputStreamReader input = new InputStreamReader(System.in); BufferedReader tastiera = new BufferedReader(input); String annostr; int annoint; System.out.println( In quale anno sei nato? ); try { annostr = tastiera.readline(); annoint = Integer.valueOf(annoStr).intValue(); //cast } catch(exception e) { System.out.println( Si è verificata un eccezione! ); } if(annoint % 4 == 0) System.out.println( Sei nato in un anno bisestile! ); else System.out.println( Non sei nato in un anno bisestile! ); } // fine main } // fine classe esbisestile Questo programma legge l anno inserito da utente nella variabile annostr. Tuttavia, come detto, l input da tastiera è sempre una sequenza di caratteri, per cui è necessario convertire annostr in un intero per poi poter valutare se si tratta di un anno bisestile oppure no. Ciò è effettuato con l istruzione: annoint = Integer.valueOf(annoStr).intValue(); Questa espressione converte il valore di annostr in un intero che poi assegna alla variabile annoint. Si tratta di due metodi della classe Integer: valueof e intvalue. Al momento non ci interessa sapere nel dettaglio come viene effettuata la conversione; si ricordi solamente che ciò permette il casting. Ad esempio le istruzioni: float annof = Float.valueOf(annoStr).floatValue(); double annod = Double.valueOf(annoStr).doubleValue(); avrebbero permesso di convertire annostr in variabili di tipo float e double rispettivamente. Infine, si può notare come nella gestione delle eccezioni il blocco catch non sia vuoto: ciò significa che, nel caso in cui si verifichi un eccezione, viene stampato a video il messaggio Si è verificata un eccezione!. Ad esempio, in questo caso vi è eccezione se il valore inserito da utente non è un numero intero (ad es ) oppure se inserisco una stringa di testo (ad es. MCMLXXXIV)

11 2.7 Le strutture di controllo Le strutture di controllo in Java sono pressoché identiche al C++. Nell esempio precedente abbiamo visto l utilizzo della struttura di selezione singola (if-else); allo stesso modo del C++ è possibile utilizzare la selezione multipla attraverso il costrutto switch-case. Per valutare la condizione in una struttura di selezione si utilizzano gli operatori logici (!,, &&) e matematici (<, <=, >, >=, ==,!=, %) esattamente come in C++. Tra le funzioni matematiche di uso comune fa invece eccezione la generazione di numeri (pseudo)casuali: anziché utilizzare srand e rand, uso il metodo random() della classe Math: double x = Math.random(); double y = Math.random() * 10; int n = (int) ( Math.random() * 5 ); int m = (int) ( Math.random() * ); Math.random() restituisce un numero casuale di tipo double tra 0.0 e 1.0 (ad es ). Nell esempio precedente quindi x sarà un numero reale tra 0 e 1 mentre y sarà un numero reale compreso tra 0 e 10 (moltiplico il numero estratto per 10). Ovviamente è anche possibile arrotondare (o meglio troncare in questo caso) il numero estratto per ottenere numeri interi; nell esempio precedente n sarà un intero compreso tra 0 e 5 mentre m sarà compreso tra 6 e 10. Le strutture di ripetizione (cicli) non si differenziano dal C++, in particolare hanno la stessa sintassi e semantica i cicli do-while, while e for. Inoltre, come per il C++, è possibile modificare l ordine di esecuzione dei cicli attraverso particolari istruzioni: break e continue. L istruzione break forza l uscita da un ciclo: se viene eseguita, l esecuzione riprende dalla prima istruzione presente dopo il ciclo (cfr. struttura switch-case). L istruzione continue invece forza il ritorno all inizio del ciclo: se viene eseguita, l esecuzione riprende dalla prima istruzione del ciclo (nel caso di for e while prima però valuto la condizione) Nel malaugurato caso che si venga a creare un loop infinito, in Java è possibile bloccare l esecuzione del programma premendo simultaneamente i tasti Ctrl + C. Esempio: Modo altamente masochista per visualizzare il valore di π approssimato a 5 cifre decimali. int k = 0; double d, pi = 1; while( true ) { d = (double) 2*k + 1; if( k % 2 == 0 ) pi += 1/d; else pi -= 1/d; k++; if( k == ) break; } System.out.println( 4 * pi ); //System.out.prinln(Math.PI)...

12 Esercizi Implementare in codice Java i seguenti esercizi: 1. Scrivere un programma che stampi a video l area di un triangolo data la base e l altezza. 2. Inserita da utente una data (a partire dal 01/01/1900), verificare se è corretta o no. 3. Visualizzare sullo schermo 10 numeri casuali compresi tra due interi a e b letti da tastiera. 4. Inserire una sequenza di numeri terminata da 0. Al termine dell inserimento visualizzare il massimo, il minimo e la media dei numeri inseriti 0 escluso. 5. Inserire da utente il nome, il cognome e l età di 5 ragazzi. Al termine dell inserimento stampare nome e cognome del ragazzo più giovane e il numero di ragazzi il cui cognome comincia con una vocale. 2.8 Gli array Un array è una collezione finita di elementi omogenei (stesso tipo). Gli array monodimensionali spesso prendono il nome di vettori, mentre quelli bidimensionali prendono il nome di matrici. Un array è realizzato mediante un puntatore che punta all'area di memoria dove si trovano i suoi elementi; ciò significa che se dichiaro un array di nome V, la variabile V non conterrà il valore dei suoi elementi ma l'indirizzo di memoria del suo primo elemento. Tuttavia, come già sottolineato, Java non permette l'utilizzo esplicito di puntatori (gestione automatica della memoria) che quindi vengono mascherati (hiding) dal linguaggio. Nonostante ciò è importante notare che un array non è un tipo primitivo, bensì un tipo reference: ciò significa che una variabile di tipo array non contiene un valore ma un riferimento ai valori contenuti nell'array (indirizzo di memoria del suo primo elemento). Per poter creare ed utilizzare un array si devono seguire tre passaggi fondamentali: DICHIARAZIONE ALLOCAZIONE INIZIALIZZAZIONE La dichiarazione consiste nella specificazione del nome dell'array e del tipo di dati che esso contiene. Un array può contenere sia tipi primitivi (ad es. int, double, ecc...) che tipi riferimento (classi oppure array stessi). La sintassi è la seguente: tipoelementi nomearray[]; Ad es. int voti[]; //oppure int[] voti; String nomi[]; //oppure String[] nomi;

13 Come si può notare, l'operatore [ ] può essere inserito equivalentemente sia dopo il nome che dopo il tipo. Si noti inoltre che al momento della dichiarazione non viene specificata la dimensione dell'array. L'istruzione di dichiarazione infatti crea una variabile di tipo array ma ad esso non associa nessun valore; la variabile array conterrà quindi il valore speciale null: ciò significa che la variabile di tipo riferimento che non si riferisce proprio a nulla. L'allocazione di un array consente di specificare la dimensione dell'array, cioè di allocare la quantità di memoria necessaria per contenere gli elementi dell'array specificato. La sintassi è la seguente: nomearray = new tipoelementi[dimensione]; Ad es. voti = new int[10]; nomi = new String[15]; Come si può notare l'allocazione viene eseguita attraverso l'operatore new. Una eseguita l'allocazione l'array non conterrà più il valore null ma l'indirizzo di memoria del primo elemento dell'array, mentre i successivi saranno memorizzati nelle celle adiacenti. Spesso comunque le operazioni di dichiarazione ed allocazione vengono effettuate contemporaneamente nella stessa istruzione: tipoelementi nomearray[] = new tipoelementi[dimensione] Ad es. int voti[] = new int[10]; String nomi[] = new String[15]; L'inizializzazione permette di inserire valori iniziali nell'array; è possibile assegnare immediatamente valori all'array al momento della dichiarazione nel seuente modo: tipoelementi nomearray[ ] = {valore1, valore2,..., valoren} Ad es. int voti[] = {4,5,6,5,7,6}; String nomi[] = { Tizio, Caio, Sempronio }; In questo modo, dichiarazione, allocazione e inizializzazione vengono fatte contemporaneamente. Tuttavia spesso l'inizializzazione viene eseguita in un momento successivo alla dichiarazione; in questo caso è necessario potersi riferire ai singoli elementi dell'array attraverso l'utilizzo di identificatori univoci: gli indici. Il primo elemento dell'array ha indice 0 Il secondo elemento dell'array ha indice 1... L'elemento n-esimo dell'array ha indice n 1

14 Un errore comune è l'utilizzo di indici che escono dai limiti dell'array: se l'array ha dimensione n, posso usare solamente indici compresi tra 0 ed n 1. Se invece utilizzo un indice i < 0 oppure i > n 1 verrà generata l'apposita eccezione ArrayIndexOutOfBoundsException. Per accedere in lettura o in scrittura all'elemento di indice i si utilizza l'operatore []: /* leggo l'elemento di indice i e lo assegno ad elem */ tipoelementi elem = nomearray[i]; /* assegno all'elemento di indice j il valore di elem */ nomearray[j] = elem; Ad es. int voti[] = new int[10]; voti[0] = 4; voti[1] = 5; int x = voti[0]; x += voti[1]; String nomi[] = new String[15]; nomi[0] = Tizio ; nomi[1] = Caio ; nomi[2] = Sempronio ; String s = nomi[0] + nomi[2]; s += nomi[1]; Un importante proprietà dell'array è l'attributo length che ne ritorna la dimensione; ad es. double temperature = new double[30]; int dim = temperature.length; //n assumerà il valore 30 Questa proprietà risulta molto utile quando si utilizzano cicli per iterare su tutti gli elementi dell'array; si veda ad esempio il seguente ciclo for: for(int i = 0; i < voti.lentgh; i++) { voti[i] = (int) ( Math.random()*9 + 1 ); System.out.println( voti[i] ); } Il ciclo scorre tutti gli elementi del vettore, assegnando ad ogni elemento un numero casuale intero tra 1 e 10 che successivamente stampa a video.

15 Esempio: /* Programma che stampa a video tutti i parametri inseriti dall'utente da riga di comando */ class parametri { public static void main(string args[]) { if(args.length == 0) System.out.println( Nessuno parametro inserito ); else { System.out.println( Hai inserito i seguenti parametri: ); for(int i=0; i < args.lenth; i++) System.out.println(args[i]); } //fine else } //fine main } //fine classe Questo programma estrae dal vettore args tutti gli argomenti passati da riga di comando (se ce ne sono) e li stampa a video. Dopo aver compilato (javac parametri.java) posso quindi eseguire il file da riga di comando; ad esempio il comando: java parametri Ciao Mondo!!! STOP produrrà il seguente output: Hai inserito i seguenti parametri: Ciao Mondo!!! STOP

16 Analogamente al C++, è inoltre possibile anche definire array bidimensionali: le cosiddette matrici. Dichiarazione: tipoelementi nomematrice[][]; Allocazione: nomematrice = new tipoelementi[numrighe][numcolonne]; Dichiarazione + Allocazione: tipoelementi nomematrice = new tipoelementi[numrighe][numcolonne]; Accesso: /* leggo l'elemento di indice di riga i e indice di colonna j e lo assegno ad elem */ tipoelementi elem = nomematrice[i][j]; /* assegno all'elemento di indice di riga i e indice di colonna j il valore di elem */ nomematrice[i][j] = elem; Esempio: /* Programma che carica una matrice 4x5 con valori interi casuali tra 0 e 5 e la stampa a video. */ class matrice { public static void main(string args[]) { int mat[] = new int[4][5]; for(int i = 0; i < 4; i++) { for(int j = 0; j < 5; j++) { mat[i][j] = Math.random() * 5; System.out.print(mat[i][j]+ ); } //fine for colonne System.out.println(); //vado a capo di una riga } //fine for righe } //fine main } //fine classe

17 Esercizi Implementare in codice Java i seguenti esercizi. Per ogni esercizio si raccomanda di stampare a video i vettori utilizzati nel formato [elem_1, elem_2,, elem_n] 1. Chiedere un numero n 0 da tastiera ed inserire in un vettore i primi n quadrati (1, 2, 4, 9, 16, 25,,n 2 ). Quindi, calcolare e visualizzare la somma, il prodotto e la media degli elementi del vettore. 2. Caricare in modo casuale due vettori di double x e y di uguale dimensione n (dove n è chiesto da utente). Quindi calcolare il prodotto scalare tra x ed y, cioè la somma dei prodotti di tutti gli elementi di indice uguale ( es. x = [1, 0, 2] e y = [2.3, 3.7, 3] 1* * *3 = 8.3 ). 3. Caricare in un vettore di 10 elementi una serie di stringhe inserite da utente; l inserimento termina quando inserisco la stringa STOP (che non va inserita nel vettore) oppure il vettore è pieno (cioè, ho già inserito 10 stringhe ). Al termine dell inserimento, stampare a video (uno sotto all altra) solo le stringhe del vettore che hanno lunghezza maggiore o uguale a Caricare in un primo vettore di 5 elementi numeri casuali interi tra 1 e 10, corrispondenti alla combinazione vincente di un gratta e vinci. Quindi leggere da tastiera 5 numeri tra 1 e 10 e inserirli in un secondo vettore, corrispondente alla vostra giocata. Infine, controllate e stampate a video quante sono le corrispondenze (cioè, stesso numero nella stessa posizione) tra la combinazione vincente e la vostra giocata. 5. Caricare un vettore vett con n numeri casuali tra 0 e 10 (n è un intero chiesto da tastiera). Visualizzare quindi: l elemento più piccolo contenuto in vett. l elemento più grande contenuto in vett. l indice del primo elemento pari di vett (se non ci sono numeri pari devo visualizzare -1). 2.9 Le eccezioni Come già accennato, un eccezione è un anomalia che si presenta durante l esecuzione del programma. Esempi classici di situazione anomala sono la divisione per zero oppure l utilizzo di un indice che esce dai limiti di un array. Come visto per la lettura di input da utente, la gestione delle eccezioni è possibile mediante l utilizzo del costrutto try-catch: try { //istruzioni da controllare (potenzialmente pericolose ) } catch(exception e) { //operazioni da eseguire se si verifica un eccezione }

18 Quando si verifica un eccezione, l esecuzione del programma si interrompe per cercare di gestirla. Se tale eccezione si verifica all interno di un blocco try, allora l esecuzione riprende a partire dalla prima istruzione di tale blocco catch. Viceversa, il programma termina segnalando un errore. Esempio: /* Questo programma genera un indice intero casuale tra 0 e 10. Successivamente carica un vettore di double di 5 elementi con numeri casuali tra 0 ed 1. Quindi prova ad accedere all elemento di indice i del vettore: se è possibile lo stampa, altrimenti gestisce l eccezione stampando a video un messaggio di errore. */ class eccezione { public static void main (String args[]) { int i = (int)(math.random()*10); double vett[] = new double[5]; for(int i = 0; i < 5; i++) vett[i] = Math.random(); try { System.out.println("indice: " + i + " elemento: " + vett[i]); } //fine try catch(exception e) { System.out.println("Si è verificata un eccezione! Impossibile accedere all'elemento di indice " + i ); } //fine catch System.out.println("Fine del programma. Bye!" ); } //fine main } //fine classe E importante notare che: Se 0 i 4, il programma non esegue il blocco catch (non c è eccezione) e viene stampato il valore di vett[i] Se invece i > 4, il programma esegue il blocco catch (ho eccezione: esco dai limiti dell array) e stampo un messaggio di errore. In entrambi i casi comunque il programma termina normalmente; viceversa se non avessi avuto un blocco try-catch in caso di eccezione il programma sarebbe terminato immediatamente segnalando un errore.