Riepilogo JAVA Seconda Parte

ESEMPIO

public class Test{

public static void metodo1(File f) throws FileNotFoundException{

if(!(f.exists())) throw FileNotFoundException();

}

public static void metodo2(File f) throws FileNotFoundException{

metodo1(f);

}

public static void metodo3(File f) throws FileNotFoundException{

metodo2(f);

}

public static void main(String[]args) throws FileNotFoundException{

metodo3(new File(“abc.txt”));

}

}

Exception in thread "main" java.io.FileNotFoundException

at Test.metodo1(Test.java:6)

at Test.metodo2(Test.java:9)

at Test.metodo3(Test.java:12)

at Test.main(Test.java:15)

i metodi vengono impilati per come riportato nella descrizione dell'eccezione, poi lo stack

si va svuotando, quindi metodo1 propaga l'eccezione a metodo2 che la propaga a metodo3

che la propaga al main che la progapa alla S.E.H. che interrompe il programma e genera

l'eccezione sopra descritta.

D: Come si gestisce un'eccezione ?

R: Per catturare un'eccezione occorre installare un gestore delle eccezioni tramite il blocco

try/catch.

Nel blocco try vanno messe tutte le istruzioni suscettibili di lanciare eccezioni, e nel/nei

blocco/blocchi catch vanno catturate tutte le eccezioni eventualmente lanciate dalle

istruzioni presenti nel blocco try. Se nel try un'istruzione lancia un'eccezione, il controllo

va subito nel blocco catch relativo a quell'eccezione.

Esempio:

try { String nomefile = args[0]; // potrebbe lanciare IndexOutOfBoundsException

Scanner in = new Scanner (new File (nomefile)); // potrebbe lanciare FileNotFoundException

}

catch ( IndexOutOfBoundsException ex ) { System.out.println("Manca "+nomefile); }

catch ( FileNotFoundException ex ){ System.out.println ("File non trovato"); }

Grazie al subtyping, un catch cattura anche istanze di sottoclassi della classe dell’oggetto

passato a parametro, quindi se nel blocco try vi sono più istruzioni dove una genera

un'eccezione che è sottoclasse di un'altra eccezione generata da un'altra istruzione, e se

sono presenti due blocchi catch di cui il primo cattura l'eccezione superclasse e l'altro

cattura l'eccezione sottoclasse, il secondo non sarà mai eseguito perchè, per subtyping,

viene eseguito dal primo blocco catch.

Esempio:

try { String nomefile = args[0]; // potrebbe lanciare IndexOutOfBoundsException

double d = 7/0; // lancia ArithmeticException

}

catch ( RuntimeException ex ) { // cattura IndexOutOfBoundsException o ArithmeticException }

catch ( ArithmeticException ex ){

// non verrà mai eseguito perché un’eccezione di tipo

// ArithmeticException verrà sempre catturata dal catch precedente }

D: E se nel try mettessi istruzioni che non generano eccezioni ?

R: Si avrebbe quest'errore in compilazione:

error: exception <nomeEccezione> is never thrown in body of corresponding try statement

D: Esiste un terzo blocco dopo try/catch?

R: Sì. Il blocco finally, le cui istruzioni, a prescindere dall'esito delle istruzioni suscettibili

di lanciare eccezioni presenti nel try, verrano comunque eseguite. Inserire il blocco finally

di solito non è obbligatorio, ma lo diventa quando non si definisce nessun blocco catch.

D: Dove posso piazzare il gestore try/catch?

R: Esso può essere inserito all'interno di un metodo invocante altri metodi suscettibili di

propagare eccezioni. L’eccezione viene dunque lanciata (o sollevata) dal metodo chiamato,

il quale la propaga, e poi viene catturata, e quindi gestita, dal metodo chiamante

D: Se creo un metodo suscettibile di lanciare eccezioni, cosa devo specificare nella

Javadoc ?

R: Nella documentazione della classe vanno specificate tutte le eccezioni che i metodi

potrebbero propagare, usando l’annotazione @throws

Es.

@throws ArithmeticException if b is equal to zero;

public int dividi(int a, int b){//istruzioni}

D: Esiste, in Java, la programmazione generica?

R: Sì. Java supporta la programmazione generica, grazie all'uso dei Generics, ossia

permette di parametrizzare classi e oggetti assegando un generico tipo T, ovvero un tipo di

una classe qualsiasi, tranne che primitivo (per lavorare con i tipi primitivi si usano le classi

wrapper). Tra i vantaggi dell'uso dei Generics, abbiamo che il compilatore può verificare

qualsiasi operazione verificando la compitabilità dei tipi e, quindi, non vi è necessità di

eseguire un casting.

D: È necessario ripetere il tipo parametrico quando si invoca il costruttore?

R: A partire da Java 7, non è più necessario scrivere il tipo parametrico all'invocazione del

costruttore, però se si omettono anche le parentesi uncinate '<>' si ottiene il seguente

warning: uses unchecked or unsafe operations.

Es.

Scrivere

ArrayList<Integer> a = new ArrayList<Integer>()

o scrivere

ArrayList<Integer> a = new ArrayList<>()

è la stessa cosa. Se invece si scrive ArrayList<Integer> a = new ArrayList() viene generato,

in compilazione, quel warning per il mancato uso dei Generics.

D: Si possono scrivere metodi generici ?

R: Sì. Si possono scrivere metodi generici e sia i parametri che il valore di ritorno saranno

generici. Per il valore di ritorno bisogna mettere il tipo generico prima del valore di

ritorno.

ESEMPIO:

public static <T> ArrayList<T> metodo(ArrayList<T> a)

metodo che prende a parametro un ArrayList di tipi T generici e restituisce qualcosa di tipo

ArrayList di tipi T.

D: Avendo due tipi di classi parametriche X<S> e X<K>, tra S e K c'è relazione di

ereditarietà tra S e K ?

R: No. Ad esempio, se avessimo le classi Persona e Studente, e volessimo istanziare un

ArrayList<Studente>, scrivere:

ArrayList<Persona> a = new ArrayList<Studente>()

è errato perchè non c'è relazione di ereditarietà tra ArrayList<Persona> e

ArrayList<Studente>.

D: Quindi come si gestisce il subtyping con i Generics ?

R: Per far ciò entrano in campo le wildcard. Possiamo parametrizzare sia una classe che un

metodo con le wildcard, oltre che col tipo generico.

Esistono due tipi di wildcard:

Unbounded: X<?> riferimento dove ? è un tipo qualsiasi non fissato

Bounded:

superiormente: X<? extends T>

– inferioremente: X<? super T>

–

dove '? extends T' indica T o un suo sottotipo, e '? super T' indica T o un suo supertipo

Esempi:

ArrayList<?> a = new ArrayList<String>();

ArrayList<? extends Persona> a = new ArrayList<Studente>();

ArrayList<? super Gatto> a = new ArrayList<Mammifero>();

D: Come implementiamo una o più interfacce ?

R: Per implementare un'interfaccia, in questo caso, dobbiamo far seguire al tipo

parametrico la parola chiave 'extends' seguita dal nome dell'interfaccia. Esempio:

public static <T extends Comparable<? super T>> T metodo()

l'esempio indica un metodo static che implementa l'interfaccia Comparable di un qualunque

supertipo di T, con il tipo T incluso.

Nel caso di implementazione di più interfacce o estensione di classe e interfaccia/e, basta

aggiungere il carattere & tra i nomi delle interfacce o tra il nome classe e l'interfaccia (o le

interfacce). Esempio:

public static <T extends Object & Comparable<? super T>> T metodo()

D: Cosa è una S.D.A. (Struttura Dati Astratta)?

R: Una SDA è una struttura definita soltanto in base alle sue proprietà e alle operazioni su

di essa fattibili, cioè è definita in base al 'cosa fa'.

D: Cosa è una struttura dati completa?

R: Una SDC è un'implementazione di una SDA e fornisce i metodi per realizzare le

operazioni, quindi il 'come fare' queste operazioni.

Esempi di implementazione della SDA 'array' sono Array e ArrayList.

Una corretta implementazione di una SDA non dovrebbe far sì che si possano compiere

operazioni che violano il concetto stesso di Struttura Dati Astratta.

D: Quali sono alcuni esempi di SDA ?

R: Alcuni esempi di SDA sono: array, matrice, insieme, stringa, lista, pila, coda, albero,

grafo, mappa e heap, ma ne esistono anche altre.

D: Come può essere implementata quindi una SDA?

R: Una SDA può essere implementata con diverse strutture dati concrete (ad esempio Array

e ArrayList implementano array) e, viceversa, una SDC può implementare diverse SDA (ad

esempio Array può essere usato per implementare array, matrici, stringhe,...).

D: Come si modellizza in Java una SDA ?

R: In Java, una SDA viene modellizzata attraverso un'interfaccia, infatti il concetto stesso di

interfaccia è quello di definire cosa fare, invece, una classe che implementa l'interfaccia

definisce come farlo.

D: Cosa è il Java Collectionc Framework (JCF) ?

R: Il JCF è una gerarchia costituita da interfacce per modellizzare collezioni di oggetti e da

classi implementanti queste interfacce.

D: Cosa fa l'interfaccia Collection?

R: L'interfaccia Collection modellizza una collezione generica astratta. I suoi metodi si

dividono in:

BASIC: operazioni di base, come inserimento, cancellazione e ricerca di un elemento

– BULK: operazioni su intere collezioni, come inserimento, cancellazione e ricerca di

–

collezioni

ARRAY: operazioni per trasformare una collezione in un array

– OPTIONAL: operazioni che, se non supportate da un'implementazione, lanciano

–

l'eccezione UnsupportedOperationException, sottoclasse di RuntimeException.

Tra i metodi di Collection vi sono:

int size() che restituisce la dimensione della collezione

– boolean isEmpty() ritorna 'true' se la collezione è vuota

– boolean add(E element) aggiunge l'emento in coda

– boolean remove(Object element) rimuove l'oggetto della collezione

– boolean contains(Object element) ritorna 'true' se vi è l'oggetto nella collezione

– Iterator<E> iterator() crea un iteratore per la collezione

– void clear() cancella tutti gli elementi della collezione

– Object[] toArray() riversa la collezione su un array di Object

– <T> T[] toArray(T[] a) riversa la collezione su un array di tipo dato

–

D: Cosa è cosa fa l'interfaccia Set?

R: L'interfaccia Set è una sottointerfaccia di Collection che modellizza un insieme, ovvero

una collezione senza duplicati. I metodi di Set realizzano le operazioni insiemistiche di

unione, intersezione, differenza e sottoinsieme:

boolean addAll(Collection<? extends E> c) unisce con un insieme dato

– boolean containsAll(Collect