13. Le eccezioni in Java

Per ambiente di sviluppo (in inglese IDE – Integrated Development Environment) si intende un software in grado di aiutarci con la scrittura del codice, segnalando errori di sintassi, suggerire il codice che stiamo scrivendo (le funzioni di autocompletamento) e molti altri tool avanzati. Vediamo i principali:

Eclipse

Ambiente di sviluppo polivalente sviluppato dalla Eclipse Foundation nel 2004. È uno degli Ide più popolari, non solo per Java, ma anche per il C, php e altro ancora.

Netbeans

Ambiente di sviluppo sviluppato da Sun e per i primi tempi ide di riferimento per Java. Quando java è passato ad Oracle ha perso popolarità in favore di Eclipse, recentemente è stato donato alla Apache Foundation.

In questo corso utilizzeremo Eclipse, diamogli quindi un’occhiata più da vicino e vediamo come creare un nuovo progetto, un nuovo package e una nuova classe.

Creazione di un progetto in Eclipse

Dal menu file clicco su new e poi su Java Project. Si aprirà una schermata come quella sottostante:

Dobbiamo semplicemente scegliere il nome del nostro progetto ignorando per ora le altre voci, che consentono delle personalizzazioni avanzate che in questa fase non ci interessano.

Creare un package in Eclipse

Sulla sinistra Eclipse visualizza una barra chiamata Package Explorer, con tutti i progetti. Per creare un nuovo package clicchiamo col tasto destro sul nome del progetto, scegliamo new e poi selezioniamo package. Si aprirà questa schermata:

inseriamo il nome del nostro package. Esiste una convenzione per cui il nome di un package comincia sempre con la lettera minuscola, è bene sempre rispettare questo tipo di convenzioni.

Creare una classe in Eclipse

Per creare una classe clicchiamo con il tasto destro sul nome del package che la deve contenere, clicchiamo su new e scegliamo class. Apparirà la seguente schermata:

Nel campo name possiamo inserire il nome della classe, che in questo caso deve iniziare con una lettera maiuscola. Questa schermata contiene varie opzioni che utilizzeremo più avanti, per ora ci concentriamo su una opzione, quella che consente di inserire il metodo main. Ogni volta che vogliamo creare una classe main (che ricordiamo è la classe che fa avviare il progetto) dobbiamo spunare la voce

public static void main(String[] args)

le prime classi che creeremo avranno tutte il metodo main

Scorciatoie di tastiera di Eclipse

Eclipse come tutti gli ide mette a disposizione diverse scorciatoie di tastiera, la più usata è data dalla combinazione:

ctrl + spazio

che serve ad attivare l’autocompletamento. I comandi in Java possono essere molto lunghi, si prenda ad esempio questo comando che vedremo a breve:

System.out.println("Hello world!")

Scrivendo solo la parola

System.out.pr

e poi usando ctrl + spazio Eclipse ci darà le opzioni per l’autocompletamento.

Hello world!

È tradizione iniziare a programmare scrivendo un programma che stampi la scritta:

Hello world!

Il codice di questo programma è il seguente

public class HelloWorld {

	public static void main(String[] args) {

		System.out.println("Hello world!");

	}

}

Come vediamo questa è una classe con il metodo main, ovvero è una classe che può essere lanciata in esecuzione. Nel metodo main vediamo una riga di codice:

System.out.println("Hello world!")

Il comando System.out.println serve per stampare: in questo caso prende in input la stringa Hello world! Quando dobbiamo scrivere questo comando possiamo usare una scorciatoia di Eclipse, scriviamo solo la parola:

syso

e poi premiamo ctrl + spazio. Eclipse trasformerà quelle quattro lettere in:

System.out.println() 

a quel punto dovremmo solo indicare a Java cosa stampare all’interno delle parentesi tonde.

Un framework è un insieme di classi, librerie o funzioni che aiutano i programmatori a sviluppare il proprio programma più velocemente. Il Java Collection Framework è una collezione di classi e interfacce sviluppata direttamente dai creatori del linguaggio Java. Le classi del Java Colection Framwork implementano strutture dati più evolute rispetto ad un array, che possono essere utilizzate in situazioni specfiche. Per Collection intendiamo una classe (o un’interfaccia che deve essere usata per creare una classe) che dispone di metodi per gestire un insieme di dati (ad esempio un insieme di stringhe, un insieme di interi ma anche dati più complessi, per esempio tipi di dati creati da noi). Esiste un’interfaccia chiamata Collection che viene estesa da tutte le interfacce del Java Collection Framework.

Le interfacce del Java Collection Framework sono:

• List
• Set
• Map
• Iterator
• Queue

Per ogni interfaccia, tranne Iterator, abbiamo un’implementazione:

• ArrayList
• HashMap
• HashSet
• PriorityQueue (e molte altre, maggiori informazioni nel paragrafo dedicato)

Nota: a differenza dell’array che è un tipo di dato primitivo, quando vogliamo usare le strutture di dati presenti nel framework dobbiamo importarle.

Il tipo di dato generico

Tutte le classi del Java collection Framwork utilizzano una caratteristica di Java: i tipi generici (generics in inglese). Questo consiste nello specificare di volta in volta

quando si crea una determianta classe che tipo di dato si vuole utilizzare. Vediamo un esempio con l’ArrayList, la prima classe di questo framework che vedremo nella prossima pagina.

		ArrayList arr = new ArrayList<>();

La riga qui sopra definisce un ArrayList di stringhe. Il tipo di dato viene specificato subito dopo il nome della classe all’interno dei simboli <>. Questo simbolo va ripetuto anche nel costruttore, in questo caso vuoto. Per ora non soffermiamoci su questo punto, più avanti nel corso del libro capiremo come mai viene ripetuto e cosa può essere inserito al suo interno.

Gli ArrayList

La classe ArrayList è l’implementazione dell’interfaccia List, consente di memorizzare gli elementi un po’ come un array, ma con alcune funzionalità in più. Come per gli array dobbiamo specificare il tipo di dato, ma si fa in modo diverso:

		ArrayList arr = new ArrayList<>();

La riga qui sopra definisce un ArrayList di stringhe.

Nota: non abbiamo fatto menzione ai numeri, perché la dimensione di un ArrayList non è fissa. Appena lo creiamo sarà vuoto, poi crescerà man mano che inseriremo elementi.

Per inserire un elemento nell’ArrayList si usa il metodo Add. Il codice sottostante inserisce nell’ArrayList la parola “ciao”:

		arr.add("ciao");

Per recuperare un elemento dall’arrayList usiamo il  metodo get. Il codice qui sotto memorizza all’interno di una variabile (in questo caso Stringa) il valore alla posizione 0 dell’arrayList:

		//recuperiamo ora un elemento

		String s = arr.get(0);

Per eliminare un elemento dall’arrayList usiamo il metodo remove. Il seguente codice  rimuoverà l’elemento alla posizione 0 dell’ArrayList:

		arr.remove(0);

Quando un elemento viene eliminato, la dimensione dell’arrayList si riduce, e gli elementi successivi indietreggiano di una posizione.

Per conoscere la dimensione di un ArrayList usiamo il metoto size, il seguente codice memorizza all’interno di una variabile la dimensione attuale dell’ArrayList

		int size = arr.size();

 Per sapere se un elemento è presente nel nostro ArrayList possiamo usare il metodo contains:

arr.contains(“nomeStringa”)

l’utilizzo più tipico è quello all’interno di un costrutto if:

		if(arr.contains(“nomeStringa”)) {

			// eseguiamo del codice se nomeStringa è presente

		}

Quando l’arrayList contiene tipi di dati complessi (esempio una classe che abbiamo definito) il metodo prenderà in input un oggetto di quel tipo e confronterà le locazioni di memoria.

Le mappe (HashMap)

Finora abbiamo visto strutture di dati che consentono un accesso basato sulla posizione: ad esempio per prendere un determinato elemento da un array dobbiamo usare il seguente codice:

		String s = arrayInt[0];

Se invece non sappiamo la posizione del nostro elemento, dobbiamo scorrere tutto l’array fino a quando non lo troviamo. Un modo alternativo di memorizzare gli elementi è quello di associare una chiave ad ognuno di essi. Ad esempio memorizzo una stringa e le assegno un nome per identificarla, ad esempio memorizzo un codice fiscale e come nome scrivo "mioCodiceFiscale" Questa stringa contenente il mio codice fiscale sarà immediatamente raggiungibile cercando la parola chiave "mioCodiceFiscale", invece di scorrere un array.

Creiamo adesso la nostra prima mappa, dobbiamo utilizzare (e quindi importare) la classe Hashmap. Nota: dobbiamo importare anche l’interfaccia Map.

import java.util.Map;

import java.util.HashMap;

Map<String,String> m = new HashMap<>();

Quando creiamo una mappa dobbiamo specificare due tipi di dati: quello della chiave

e quello dell'elemento che vogliamo memorizzare. Nel nostro caso, supponendo di voler memorizzare dei codici fiscali, avremmo come tipo di dato String per la chiave (ed codiceFiscaleGiovanni) e String per il valore (ES RSSGNN90S05A592N)

Per inserire un elemento in una mappa si usa il metodo put, che prenderà in input una coppia nome valore del tipo specificato al momento della creazione della mappa.

	m.put("CodiceFiscaleGiovanni", "RSSGNN90S05A592N");

Per recuperare un elemento dalla mappa si usa invece il metodo get. Continuando con il nostro esempio, per prendere il codice fiscale che abbiamo inserito prima scriveremo:

	String codiceFiscale = m.get("CodiceFiscaleGiovanni");

Nota: i nomi devono essere univoci, nell’esempio qui sopra abbiamo inserito nella mappa una chiave chiamata  CodiceFiscaleGiovanni, non possiamo inserire altre chiavi con lo stesso nome, altrimenti il valore precedente con la stesa chiave verrà sovrascritto.

Se infatti dopo aver scritto i codici sopra scriveremo:

 	m.put("CodiceFiscaleGiovanni", "RSSGNN74S09A592K");

Il valore precedentemente memorizzato verrà sovrascritto e quando proveremo a recuperare questo dato dalla mappa otterremo "RSSGNN74S09A592K"

Per rimuovere un elemento dalla mappa si usa il metodo remove che ha come parametro la parola chiave che abbiamo inserito al momento della creazione di quell’elemento. Ad esempio se voglio rimuovere il codice fiscale inserito sopra scriverò:

	m.remove("CodiceFiscaleGiovanni");

Facciamo ora un altro esempio: supponiamo di dover memorizzare i dati dei nostri utenti. Abbiamo una classe Utente che contiene i dati, e dobbiamo memorizzarli in una mappa. Il codice che scriveremo sarebbe questo:

Map<String,Utente> m = new HashMap<>();

Per inserire un oggetto scriveremo: 

	m.put("UtenteGiovanni", u);

Dove u è un oggetto di tipo utente.

Gli insiemi (HashSet)

Un insieme è un tipo di dato che non ammette duplicati, ovvero non possiamo inserire più di una volta la stessa chiave. Sugli insiemi possiamo eseguire le operazioni dell’insiemistica, ovvero l’intersezione, l’unione e cosi via. Per creare un insieme dobbiamo importare queste classi:

import java.util.Set;

import java.util.HashSet;

Creiamo il nostro primo insieme, che conterrà delle stringhe:

Set set = new HashSet<>();

Aggiungiamo i nostri primi elementi:

	set.add("a");

	set.add("b");

Nota: gli insiemi non accettano duplicati. Se inseriamo ad esempio questo codice:

	set.add("c");

	set.add("c");

nell’insieme troveremo comunque un solo elemento “c”.

Operazioni con gli insiemi

Per eseguire l’intersezione di due insiemi dobbiamo usare il metodo retainAll().

	set.retainAll(set2);

Questo metodo va invocato su un insieme e ha bisogno di un altro insieme come parametro ed eliminerà nell’insieme su cui è stato invocato tutti gli elementi che non fanno parte di set2.

Dati questi insiemi:

set1 = [A, B, C]

set2 = [A, D]

l’esecuzione del metodo retainAll con questi due insiemi porterà a questo insieme:

risultato = [A]

Per eseguire l’unione usiamo invece il metodo addAll()

	set.addAll(set2);

questo metodo aggiunge il contenuto dell’insieme passato come parametro all’interno dell’insieme su cui è invocato. Ovviamente se ci sono duplicati non troveremo due volte lo stesso valore.

Dati questi insiemi:

set1 = [A, B, C]

set2 = [A, D]

l’unione di questi insiemi porterà ad avere questo nuovo insieme:

risultato = [A, B, C, D]

Le code

Una coda (queue in inglese) è una struttura dati che si comporta proprio come una coda ad una cassa o ad un ufficio. I dati inseriti al suo interno sono ordinati in ordine di arrivo e verranno eliminati nello stesso ordine. Questo approccio si definisce FIFO (first in first out), ovvero il primo elemento che viene inserito nella coda sarà il primo ad uscire. Le code vengono utilizzate quando il programma che dobbiamo realizzare richiede di svolgere alcune operazioni in ordine di arrivo. Si pensi ad esempio ad un programma che gestisce le richieste di assistenza dei clienti: un tecnico che si libera deve sapere qual è la prossima richiesta di assistenza a cui deve lavorare. Questa situazione potrebbe essere gestita con una coda

Diversi tipi di code

Il tda coda cosi come descritto sopra è solo una base, sono stati sviluppati diversi tipi di code adatti a diverse esigenze. Vediamone le principali:

• Coda a priorità
  Si tratta di una coda che aggiunge, all’approccio FIFO, una variante legata alla priorità di un elemento inserito.
• Coda sincronizzata
  Si tratta di un tipo di coda utilizzato nella programmazione concorrente, ovvero quando più processi di un programma accedono contemporaneamente alla coda.

Esistono molti altri tipi di code, ma per i nostri fini didattici utilizzeremo un’implementazione delle code a priorità chiamata PriorityQueue, che in caso di priorità tutte uguali si comporterà esattamente secondo il principio FIFO, altrimenti terrà conto delle priorità.

		PriorityQueue queue = new PriorityQueue<>();	

Aggiungere un elemento nella coda

		queue.add("Lucia");

Rimuovere il prossimo elemento nella coda

Per rimuovere l’elemento primo in lista nella coda si usa il metodo remove. Il metodo restituisce l’oggetto rimosso  in una variabile.

		String elementoRimosso = queue.remove();

Conoscere il primo elemento della coda

In alcuni casi potremmo sapere qual è il prossimo elemento della coda, senza però rimuoverlo. In questi casi possiamo usare il metodo peek:

		String elemento = queue.peek();	

		// conoscere la dimenzione di una coda

		int size = queue.size();

Gli stack

Una pila (stack in inglese) è una struttura dati che si comporta in maniera opposta alla coda: il primo elemento ad essere inserito sarà il primo ad essere restituito. Immaginiamo una pila di libri: mettiamo l’uno sull’altro diversi libri, quando dobbiamo riprenderli per ordinarli il libro in cima sarà l’ultimo libro che abbiamo posto su di essa. Java mette a disposizione la classe Stack per implementare questa struttura dati.

Creiamo il nostro primo stack:

Come per gli altri elementi del Java Collection Framework dobbiamo specificare il tipo di dato, nel nostro caso String.

	Stack stack = new Stack<>();

Aggiungere elementi

Per aggiungere un elemento allo stack utilizziamo il metodo add:

	stack.add("Luca");

possiamo anche decidere dove inserirlo, specificando una posizione

	stack.add(2, "Antonio");

Rimuovere elementi

Per rimuovere elementi dallo stack si usa il metodo remove. Questo metodo richiede di specificare la posizione da rimuovere, questo ci consente di seguire la logica degli stack quando questa ci serve, mettendo come indice 0:

	String elementoRimosso = stack.remove(0);

Possiamo però decidere di non seguire questa logica e rimuovere un qualsiasi altro elemento.

Gli iteratori

Vediamo ora un altro importante elemento del java collection framework, la classe Iterator. Questa classe consente di iterare tutti gli elementi di una qualsiasi classe del java collection framework

Dispone di un metodo hasNext per sapere se ci sono ancora elementi, e del metodo next per recuperare il prossimo elemento.

Nota che l'iteratore non consente di tornare indietro, quando un elemento viene restituito non può essere richiesto nuovamente. L'iteratore invia tutti gli elementi una volta sola, quando restituisce l'ultimo elemento si è esaurito. Ne consegue che gli iteratori possono essere usati una volta sola.

Supponiamo di avere una variabile set che è un insieme contenente questi valori: [a, b, c, d, e, f, g, h, i]

possiamo creare un iteratore di questo insieme in questo modo

	Iterator it = set.iterator();

Come gli altri elementi del Java Collection Framework anche per gli iteratori bisogna specificare il tipo di dato tra i simboli <>. Il tipo di dato deve ovviamente coincidere con quello della classe su cui si invoca l'iteratore. Per scorrere tutti gli elementi dell’iteratore usiamo:

		 while(it.hasNext()) {

			 String elem = it.next();

			 System.out.println(elem);

		 }

Nell’esempio qui sopra stampiamo l’elemento, ma potremmo compiere le operazioni più disparate. 

L'iteratore può essere invocato su liste, set, code e altri elementi del java collection framework, ma non si può invocare direttamente su una mappa, perché è una collezione di elementi nome - valore. Per usarlo sulla mappa invochiamo il metodo keyset e che restituisce un insieme delle chiavi e poi invochiamo su di esso l'iteratore. Vediamo un esempio qui sotto, supponiamo di avere una mappa m con un certo numero di elementi.

		 Iterator it = m.keySet().iterator();

		 while(it2.hasNext()) {

			 String elem = it.next();

			 System.out.println(m.get(elem));

		 }

Java è un linguaggio di programmazione ad oggetti tra i più comuni al mondo, utilizzato praticamente in tutti i tipi di dispositivi, dai computer ai telefoni, distributori automatici e molto altro. Fu creato da Sun Microsystem nel 1995 ed è poi passato ad Oracle quando quest’ultima ha acquisito Sun.

La macchina virtuale Java

Una caratteristica di Java è quella di girare su tutti i sistemi operativi, senza che il codice venga ricompilato come avviene in altri linguaggi. Questa possibilità ci è data dalla Java Virtual Machine, che si occupa di leggere il codice Java tradurlo nel linguaggio macchina del dispositivo dove si trova.

Organizzazione del codice

Il codice Java è organizzato in classi, che sono contenute in package.  Per ora ci basti sapere che una classe è un file contenente codice Java, può richiamare altre classi per fare compiti specifici. Le classi a loro volta sono suddivise in metodi, che possono essere richiamati dalla stessa classe o da altre classi.

Un programma java può avere un numero variabile di classi che può essere anche molto elevato (si pensi per esempio a programmi come Eclipse). Un programma Java deve avere sempre una classe che viene chiamata quando il programma va in esecuzione. Questa classe è chiamata classe main, capiremo più avanti questo concetto.

Un package è una cartella che contiene le classi Java.  I progetti java possono essere molto vasti, quindi è necessario ordinare le classi in modo da essere consultabili. Ad esempio supponiamo di avere un programma di una biblioteca, un package potrebbe contenere tutte le classi Java deputate al salvataggio dei dati e un altro potrebbe contenere tutte le classi deputate alla gestione dell’interfaccia grafica.

Commenti

I commenti sono delle stringhe di testo che vegono utilizzate per spiegare il codice che si sta scrivendo. Quando scriviamo un programma non è detto che lo utilizzeremo solo noi, può darsi che quel codice vada in mano ad un collega. È bene quindi commentarlo per far capire a chi legge il codice (anche a noi stessi, se lo rileggiamo dopo un po’ di tempo!) cosa abbiamo fatto.I commenti in java si fanno in due modi:

// commento su singola riga

/*

 * commento su più righe

 * lo utilizziamo quando dobbiamo spiegare qualcosa di più elaborato

 */