La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

1: Java notes1 Argomenti della lezione r Interfacce  Eccezioni r IO in Java r Collection r Esercizio riassuntivo: un’applicazione.

Presentazioni simili


Presentazione sul tema: "1: Java notes1 Argomenti della lezione r Interfacce  Eccezioni r IO in Java r Collection r Esercizio riassuntivo: un’applicazione."— Transcript della presentazione:

1 1: Java notes1 Argomenti della lezione r Interfacce  Eccezioni r IO in Java r Collection r Esercizio riassuntivo: un’applicazione

2 1: Java notes2 Interfacce r Permette al programmatore di stabilire la struttura di una classe: nomi dei metodi, argomenti e tipi restituiti (in una parola i prototipi dei metodi), ma non i corpi degli stessi. Può, inoltre, contenere variabili d’istanza (campi), ma queste sono implicitamente static e final. r Un’interfaccia fornisce solo una struttura, ma non un’implementazione

3 1: Java notes3 Interface r Per creare un’interfaccia si usa la parola chiave interface al posto di class. r Come per una classe si può dichiarare un’interaccia public (solo se definita in un file con lo stesso nome). Senza dichiarazione esplicita l’interfaccia sarà utilizzabile solo all’interno dello stesso package cui appartiene.

4 1: Java notes4 Interfacce, ereditarietà e polimorfismo r Mentre in Java una classe può ereditare da una sola altra classe (sia essa normale od abstract), essa può però ereditare da più interfacce. r Tutte le interfacce da cui una classe sta ereditando vanno scritte separate fra loro da virgole dopo la parola chiave implements. r Si può ereditare da quante interfacce si vuole, ciascuna delle quali diviene un tipo indipendente verso il quale si può effettuare l’upcasting. r Se una classe eredita sia da una classe che da una o più interfacce contemporaneamente, l’elenco di interfacce deve seguire la classe concreta (in caso contrario il compilatore da un errore).

5 1: Java notes5 Esempio 1/2 r Albero delle dipendenze

6 1: Java notes6 Esempio 2/2 import java.util.*; interface Instrument { // Compile-time constant: int i = 5; // static & final // Cannot have method definitions: void play(); // Automatically public String what(); void adjust(); } class Wind implements Instrument { public void play(){ System.out.println("Wind.play()"); } public String what() { return "Wind"; } public void adjust() {} } class Percussion implements Instrument { public void play(){ System.out.println("Percussion.play()"); } public String what() { return "Percussion"; } public void adjust() {} } class Stringed implements Instrument { public void play() { System.out.println("Stringed.play()"); } public String what() { return "Stringed"; } public void adjust() {} } class Brass extends Wind { public void play() { System.out.println("Brass.play()"); } public void adjust() { System.out.println("Brass.adjust()"); } } class Woodwind extends Wind { public void play() { System.out.println("Woodwind.play()"); } public String what() { return "Woodwind"; } } public class Music { // Doesn't care about type, so new types // added to the system still work right: static void tune(Instrument i) {i.play(); } static void tuneAll(Instrument[] e) { for(int i = 0; i < e.length; i++) tune(e[i]); } public static void main(String[] args) { Instrument[] orchestra = new Instrument[5]; int i = 0; // Upcasting during addition to the array: orchestra[i++] = new Wind(); orchestra[i++] = new Percussion(); orchestra[i++] = new Stringed(); orchestra[i++] = new Brass(); orchestra[i++] = new Woodwind(); tuneAll(orchestra); } }

7 1: Java notes7 Ancora sull’ereditarietà r Usando l’ereditarietà è posibile aggiungere nuovi metodi alle interfacce, così come è possibile combinare diverse interfacce fra loro in una nuova interfaccia. interface Monster { void menace(); } interface DangerousMonster extends Monster { void destroy(); } interface Lethal { void kill(); } class DragonZilla implements DangerousMonster { public void menace() {} public void destroy() {} } interface Vampire extends DangerousMonster, Lethal { void drinkBlood(); } public class HorrorShow { static void u(Monster b) { b.menace(); } static void v(DangerousMonster d) { d.menace(); d.destroy(); } public static void main(String[] args) { DragonZilla if2 = new DragonZilla(); u(if2); v(if2); } }

8 1: Java notes8 Inoltre r Ogni campo di un’interfaccia è automaticamente static e final, quindi l’interfaccia ben si presta alla realizzazione di gruppi di costanti come, ad esempio, accade facendo uso di un enum in C o C++. r I campi di un interfaccia sono automaticmente public anche se non esplicitamente specificato. Essendo inoltre static e final, devono essere inizializzati. I valori di tali campi possono essere assegnati una volta per tutte, per mezzo di espressioni non costanti che vengono calcolate nell’istante della loro creazione.

9 1: Java notes9 Esempio public interface Months { int JANUARY = 1, FEBRUARY = 2, MARCH = 3, APRIL = 4, MAY = 5, JUNE = 6, JULY = 7, AUGUST = 8, SEPTEMBER = 9, OCTOBER = 10, NOVEMBER = 11, DECEMBER = 12; } import java.util.*; public interface RandVals { int rint = (int)(Math.random()*10); long rlong = (long)(Math.random()*10); float rfloat = (float)(Math.random()*10); double rdouble = Math.random()*10; } public class TestRandVals { public static void main(String[] args) { System.out.println(RandVals.rint); System.out.println(RandVals.rlong); System.out.println(RandVals.rfloat); System.out.println(RandVals.rdouble)} }

10 1: Java notes10 Eccezioni r Un’eccezione è un segnale indicante il verificarsi di un’errore o di una condizione anomala nell’esecuzione del programma. Lanciare un’eccezione significa segnalarne l’occorrenza, mentre catturarla significa captare il suddetto segnale e gestire tale eccezione. r L’eccezione è un’oggetto, istanza della classe (o di una sottoclasse di) java.lang.Throwable. Esistono due sue sottoclassi standard di eccezioni in Java: m java.lang.Error –corrispondenti ad errori irrecuperabili (memoria della JVM esaurita, class-file corrotto). m java.lang.Exception –corrispondono a errori meno gravi e possono essere catturate e gestite con del codice adeguato.

11 1: Java notes11 Gestire le eccezioni: try - catch r L’istruzione try identifica un blocco di codice che può generare eccezioni in modo che queste vengano catturate. r Uno o più blocchi identificati dall’istruzione catch seguono il blocco try e contengono il codice per la gestione di un particolare tipo di eccezione. L’istruzione catch ha un solo argomento, che specifica la classe a cui appartiene l’oggetto eccezione che il blocco può gestire. r Quando viene lanciata un’eccezione, si interrompe l’esecuzione del codice e si cerca un blocco catch il cui argomento è un’istanza della stessa classe (o di una superclasse) dell’eccezione lanciata. Se non esiste nel metodo corrente, viene cercato nel metodo che ha invocato il metodo corrente, e cosi’ via a ritroso fino ad arrivare al metodo main(). Se non vene trovato neanche lì, l’esecuzione del programma viene terminata con un messaggio d’errore.

12 1: Java notes12 Throws e throw r Un metodo può lanciare un’eccezione, eventualmente creata dal programmatore, con l’istruzione throw. r Tutti i metodi Java possono usare la clausola throws per gestire le eccezioni: throws lista di sottoclassi della classe Exception che possono essere lanciate dal metodo r La clausola throws è aggiunta nell'intestazione della definizione di un metodo: public static void main(String[] args) throws Exception {...} r Alcune eccezioni sono verificate (checked) in compilazione e devono essere menzionate nella clausola throws di qualunque metodo che le lancia con un'istruzione throw, oppure le propaga tramite altri metodi. Le eccezioni non-verificate (unchecked) sono oggetti del tipo RunTimeException. Non è richiesto che le sotto classi della classe RunTimeException vengano menzionate nella clausola throws (da qui unchecked).

13 1: Java notes13 Gestione eccezioni parenti r Attenzione: m se Exception2 è una sottoclasse di Exception1, si può usare solo un blocco catch relativo a Exception1: tale blocco gestisce entrambi i tipi di eccezioni. m se si vuole gestire le due eccezioni in modo differente occorre mettere prima il blocco che gestisce l’eccezione figlia Exception2 e poi quello che gestisce l’eccezione genitore Exception1.

14 1: Java notes14 Blocco finally r I blocchi catch possono opzionalmente essere seguiti da un blocco finally contenente codice di “pulizia” la cui esecuzione è garantita, qualunque cosa succeda nel blocco try. r Appena l’esecuzione lascia il blocco try, prima di passare altrove, viene eseguito il codice contenuto nel blocco finally. r Ogni blocco try deve essere seguito da (almeno) un blocco catch e/o un blocco finally. r Ognuno dei blocchi deve iniziare e finire con le parentesi graffe (anche se composti da una sola istruzione)

15 1: Java notes15 Esempio public void unMetodo() throws MyException { Try { … (qui é contenuto del codice che può lanciare un’eccezione di tipo SomeException, oppure un’eccezione di tipo AnotherException) } catch(SomeException e1) { … (codice che gestisce un’eccezione di tipo SomeException) } catch(AnotherException e2) { … (codice che gestisce un’eccezione di tipo AnotherException) } finally { … (codice che viene sempre eseguito, dopo essere usciti per qualsiasi motivo dal blocco try – tranne nel caso in cui viene invocato il metodo System.exit() il quale interrompe l’esecuzione dell’interprete Java) } if (condizione) throw new MyException(); // questa non viene gestita direttamente dal // metodo che la sta lanciando }

16 1: Java notes16 IO in Java: Stream r Stream: canale di comunicazione tra un programma (Java) e una sorgente (destinazione) da cui importare (verso cui esportare) dati r L’informazione viene letta (scritta) serialmente, con modalità FIFO r Read Only o Write Only: servono due stream per un canale bi-direzionale r Bloccante r Quasi tutti i metodi possono generare eccezioni r Il package java.io contiene classi che implementano gli stream LetturaScrittura Apri lo stream while (ci sono ancora dati) leggi dato chiudi lo stream Apri lo stream while (ci sono ancora dati) scrivi dato chiudi lo stream

17 1: Java notes17 Tipi di Stream r Due gerarchie di classi: m Stream di caratteri: per leggere/scrivere caratteri UNICODE a 16 bit m Stream di byte: per leggere/scrivere byte (tipicamente dati)

18 1: Java notes18 Stream di caratteri r Implementati dalle superclassi abstract Reader e Writer r Reader: contiene una parziale implementazione e le API (metodi e campi) per realizzare stream che leggono caratteri r Writer: contiene una parziale implementazione e le API (metodi e campi) per realizzare stream che scrivono caratteri r Sottoclassi di Reader e Writer implementano stream specializzati

19 1: Java notes19 Stream di caratteri/2 r Classi grigie: leggono/scrivono e basta r Classi bianche: compiono anche qualche tipo di elaborazione

20 1: Java notes20 Stream di byte r Implementati dalle superclassi abstract InputStream e OutputStream r InputStream: contiene una parziale implementazione e le API (metodi e campi) per realizzare stream che leggono byte r OutputStream: contiene una parziale implementazione e le API (metodi e campi) per realizzare stream che scrivono byte r Sottoclassi di InputStream e OutputStream implementano stream specializzati

21 1: Java notes21 Stream di byte/2 r Classi grigie: leggono/scrivono e basta r Classi bianche: compiono anche qualche tipo di elaborazione

22 1: Java notes22 Estensioni degli stream - Filtri r Caratteristiche fondamentali dei filtri: m Sono classi derivate da InputStream e OutputStream m Si attaccano a un InputStream o OutputStream: chiamare write() su un filtro significa chiamare anche write() sull’OutputStream attaccato m E’ possibile combinare in serie diversi filtri ottenendo combinazioni potenti m In pratica, si usano sottoclassi di FilterOutputStream e FilterInputStream FilterOutputStream OutputStream InputStream FilterInputStream

23 1: Java notes23 InputStreamReader/ InputStreamWriter r Sottoclassi di Reader/Writer r Creano un ponte tra stream a byte e a carattere r Costruttori: m public InputStreamReader(InputStream in): accetta un oggetto InputStream e crea un oggetto InputStreamReader (e dunque Reader) m public OutputStreamWriter(OutputStream out): accetta un oggetto di tipo OutputStream e crea un oggetto di tipo OutputStreamWriter (e dunque Writer) m Altri costruttori permettono di specificare una codifica

24 1: Java notes24 InputStreamReader/ InputStreamWriter/2 r La codifica permette di associare byte e caratteri r Esempio: i byte dello stream sottostante possono rappresentare caratteri codificati in formato UNICODE a 16 bit InputStreamReader InputStream (codifica – Es. UN 16 bit) byte char La situazione è analoga per un OutputStreamWriter

25 1: Java notes25 BufferedReader/ BufferedWriter r Realizzano buffering per rendere più efficienti le operazioni di I/O su stream di caratteri r Costruttori: m public BufferedReader(Reader in) m public BufferedReader(Reader in, int sz) m public BufferedWriter(Writer out) m public BufferedWriter(Writer out, int sz) sz: dimensione del buffer r Metodo più importante: m public String readLine() throws IOException: legge una linea di testo, restituendo la stringa corrispondente

26 1: Java notes26 System.in/System.out I/O standard r in e out sono membri (variabili static final) della classe System r in è di tipo InputStream, out di tipo OutputStream (è in realtà oggetto di classe PrintStream, una sottoclasse di OutputStream) import java.io.*; public class classeLettura { public static void main(String args[]) throws IOException { InputStream stdIn = System.in; InputStreamReader in = new InputStreamReader(stdIn); BufferedReader myReader = new BufferedReader(in); String inputLine; myReader.readLine(); System.out.println("Hai scritto "+inputLine); }

27 1: Java notes27 La gestione dei file in Java r In Java esiste la classe File che è una rappresentazione astratta di file e directory r La classe File possiede metodi per manipolare file e directory, ma non per leggere/scrivere r La lettura/scrittura su/da un file viene effettuata attraverso l’associazione di uno stream all’oggetto di classe File r Se il file non esiste, esso è effettivamente creato solo quando si apre uno stream verso di esso r Costruttore principale: m public File(String pathname) throws NullPointerException

28 1: Java notes28 Gli stream di lettura e scrittura orientati ai byte per file r FileInputStream/FileOutputStream m Sono sottoclassi di InputStream e OutputStream che aprono stream di byte da/verso file. m Hanno gli stessi metodi di InputStream e OutputStream m Si possono applicare i filtri (ad esempio DataInputStream e DataOutputStream) m Costruttori principali: public FileInputStream(File file) throws FileNotFoundException public FileOutputStream(File file) throws FileNotFoundException

29 1: Java notes29 Gli stream di lettura e scrittura orientati ai caratteri per file r FileReader/FileWriter: m Sono sottoclassi di Reader e Writer che aprono stream di caratteri da/verso file m Hanno gli stessi metodi di Reader e Writer m Si possono applicare i filtri (ad esempio BufferedReader e BufferedWriter) m Costruttori principali: public FileReader(File file) throws FileNotFoundException public FileWriter(File file) throws FileNotFoundException

30 1: Java notes30 Tenere oggetti: Collection e Map r Java presenta 2 diverse librerie al fine di contenere oggetti, basate su due distinti approcci: m Collection: un gruppo di elementi individuali, soggetti a particolari regole. Ad esempiouna List deve tenere oggetti in una particolare sequenza, un Set non può avere elementi duplicati. m Map: un gruppo di oggetti chiave-valore.

31 1: Java notes31 Tassonomia delle contenitori

32 1: Java notes32 Liste, stack e code in Java r Questi dati sono rappresentati e implementati da interfacce e classi del package Java.util (in realtà strutture dati più ricche) r L’interfaccia più generale è Collection r Rappresenta un insieme di elementi, eventualmente replicati (multinsieme) r Ammette operazioni di inserimento e cancellazione

33 1: Java notes33 Tipo di dato Lista r Insieme di elementi tra i quali è definito un ordinamento totale. r Ammette (almeno) le operazioni seguenti: m insert(elem, i): inserisce elem in posizione i-esima m remove(i): elimina l’i-esimo elemento della lista r Altre operazioni possibili (non tutte): m findkth(i): restituisce l’i-esimo elemento m isEmpty: restituisce vero se la lista è vuota

34 1: Java notes34 Liste in Java r E’ un’interfaccia r Rappresenta una collezione ordinata di elementi r Ammette duplicati r Implementazioni: classi LinkedList, ArrayList e Vector

35 1: Java notes35 Classe Vector Array: r Può contenere solo oggetti appartenenti allo stesso tipo di dato r Dimensione fissa r Pochi metodi ma maggiore efficienza Classe Vector r Contiene Object. I tipi di dati primitivi devono essere convertiti mediante gli opportuni wrapper. r Gestione flessibile dello spazio di memoria. r Gran numero di metodi a scapito dell'efficienza

36 1: Java notes36 Esempi di utilizzo delle classi Vector ed Enumeration Vector v = new Vector(); String st = br.readLine();// br di tipo BufferedReader while (st != null) { v.addElement(st); st = br.readLine(); } Enumeration e = v.elements(); while (e.hasMoreElements()) { String s t= (String)e.nextElement();// il metodo nextElement // restituisce un oggetto di classe Object per cui occorre // usare l'operatore di cast. System.out.println(st); }

37 1: Java notes37 Vettore di tipi di dato primitivi Vector v = new Vector(); String st = br.readLine();// br di tipo BufferedReader while (st != null) { int num = Integer.parseInt(st); v.addElement(new Integer(num)); st = br.readLine(); } Enumeration e = v.elements (); while (e.hasMoreElements()) { Integer I = (Integer)e.nextElement(); // I : oggetto della classe Integer int i = I.intValue(); // i : variabile del tipo primitivo int System.out.println(i); }

38 1: Java notes38 Tipo stack r Lista nella quale inserimenti e cancellazioni avvengono solo in coda (disciplina LIFO). r Operazioni: m clear(): elimina tutti gli elementi dalla pila m isEmpty(): verifica se la pila è vuota m isFull(): verifica se la pila è piena m push(el): inserisce l'elemento specificato da el in cima alla pila m pop(): elimina l'elemento in cima alla pila m topEl(): restituisce l'elemento in cima alla pila senza cancellarlo dalla lista

39 1: Java notes39 Implementazione tramite java.util.Stack r Java fornisce una classe Stack che implementa il tipo di dato primitivo stack: m Costruttore: Stack Stack(): Crea una pila vuota m Metodi: boolean empty(): restituisce true se la pila è vuota Object peek(): realizza l'operazione topEl() Object pop(): rimuove e restituisce l'elemento affiorante Object push(el): inserisce l'elemento specificato in cima alla pila int search(el):restituisce la posizione di el all'interno della pila


Scaricare ppt "1: Java notes1 Argomenti della lezione r Interfacce  Eccezioni r IO in Java r Collection r Esercizio riassuntivo: un’applicazione."

Presentazioni simili


Annunci Google