Scarica Riassunto linguaggio java e più Sintesi del corso in PDF di Fondamenti di informatica solo su Docsity!
SINTASSI JAVA
NOTAZIONE E RAPPRESENTAZIONE NUMERI E CARATTERI
CLASSE JAVA
public class NomeClasse definisce una nuova classe import.nomePacchetto.NomeClasse; importa una classe import java.util.Scanner;
VARIABILI E COSTANTI
In Java tutti i tipi di dati fondamentali per numeri interi usano internamente la rappresentazione in complemento a due.
- La JVM non segnala le condizioni di overflow nelle operazioni aritmetiche, si ottiene semplicemente un risultato errato
- L’unica operazione aritmetica tra numeri interi che genera una eccezione è la divisione con divisore zero ( ArithmeticException ) Se si usasse il valore di una variabile prima di averle assegnato un qualsiasi valore, il programma si troverebbe ad elaborare quel valore che “casualmente” si trova nello spazio di memoria riservato alla variabile. Il compilatore Java segnala come errore l’utilizzo di variabili a cui non sia mai stato assegnato un valore (mentre non è un errore la sola definizione...). Questi errori non sono sintattici, bensì logici, ma vengono comunque individuati dal compilatore, perché si tratta di errori semantici.
nomeVariabile = valore; assegnazione di un valore ad una variabile nomeTipo nomeVariabile = espressione; definisce una variabile int num = 000; definisce una variabile di tipo int e di nome num float num = 13.9f; definisce una variabile di tipo float e di nome num String greeting = “abcd”; definisce un oggetto di tipo string e di nome greeting 1.93E3 vale 1.93 * 10³ esprime un numero in forma esponenziale final nomeTipo NOME_COSTANTE = espressione; definisce una costante final double EURO_PER_DOLLAR = 0.72; num += 33; incrementa la variabile num di 33 num -= 33; decrementa la variabile num di 33 counter++; incrementa la variabile counter di 1 counter--; decrementa la variabile counter di 1
OGGETTI
Un oggetto è un’entità che può essere manipolata in un programma mediante l’invocazione di metodi. NomeClasse nomeOggetto; definisce una variabile oggetto new NomeClasse (parametri); crea un nuovo oggetto Rectangle box = new Rectangle (5,10,20,20); Rectangle box2 = new Rectangle (box.getX(), box.getY(), box.getWidth(), box.getHeight() ); box2.translate(15,25); trasla il rettangolo Rectangle box = new Rectangle (5,10,20,20); Rectangle box2 = box; fa riferimento all'oggetto box, usando box o box2 modifico lo stesso oggetto
STRING E CHAR
int n = greeting .length(); population .trim() elimina gli spazi alla fine String r = river .replace(“issipp”,”our”); String big= river .toUpperCase(); String small= river. toLowerCase(); L’applicazione di questi metodi non altera il contenuto della stringa s, ma restituisce una nuova stringa! In generale, nessun metodo della classe String modifical’oggetto con cui viene invocato!! si dice perciò che gli oggetti della classe String sono oggetti immutabili. La posizione dei caratteri nelle stringhe viene numerata a partire da 0 anziché da 1 String sub = greeting .substring(0,4); salva i caratteri dalla posizione 0 alla posizione 3 ovvero i primi 4. 0-4 individua la lunghezza della sottostringa. La posizione dell'ultimo carattere corrisponde alla lunghezza della stringa meno 1. String sub = greeting .substring(7); salva i caratteria dalla posizione 7 alla fine della stringa String s = euro + “” + euroName; concatena tre stringhe (di cui una è la stringa vuota) int age= Integer.parseInt(ageString); converte una stringa contenente un numero intero in int double number = Double.parseDouble(numberString); String s = “” + numInt; converte un numero in una stringa (brutto) String s = Integer.toString(numInt); converte un numero intero in una stringa String s = Double.toString(numDouble); converte un numero in virgola mobile in una stringa char ch = s.charAt(2); restituisce il singolo carattere nella posizione 2 della stringa s char ch = 'x'; definisce una variabile di tipo char char ch = '\u00E9'; la lettera “è” è definita mediante una SEQUENZA DI ESCAPE
Impostazioni locali nell'uso dell'input standard A partire dalla JDK5.0 e nelle seguenti versioni, alcune funzioni di ingresso/uscita sono dipendenti da convenzioni in uso localmente, dette impostazioni locali. Esempi di impostazioni locali sono il formato dell'ora e il carattere di separazione nei numeri espressi in virgola mobile (come enoto, nel mondo anglosassone il carattere di separazione fra la parte intera e la parte frazionaria e il carattere '.', mentre in Italia eil carattere ','). Quando si usano oggetti di classe **java.util.Scanner** per acquisire dati in ingresso, il programmatore puo decidere esplicitamente l'impostazione locale. Se non sceglie, viene automaticamente usata l'impostazione dell'elaboratore su cui viene eseguito il programma, detta impostazione di default. La scelta dell'impostazione locale si fa invocando sull'oggetto di classe Scanner il metodo useLocale(Locale locale) , che accetta come parametro un oggetto di classe Locale del pacchetto java.util. La classe java.util.Locale contiene la definizione di comodi oggetti costanti da usare come parametro; ad esempio:
- Locale.US oggetto costante per le impostazioni locali americane (USA)
- Locale.ITALY oggetto costante per le impostazioni locali italiane Di seguito un esempio di uso esplicito di impostazioni locali: import java.util.Scanner; import java.util.Locale; ... Scanner in = new Scanner(System.in); in.useLocale(Locale.US); // usa la convenzione USA .... Approfondimento Anche gli oggetti di classe java.io.PrintStream come System.out possono adoperare impostazioni locali. In questo caso si usa il metodo format(Locale locale, String format, Object ...args) che invia a standard output la stringa format. Si usano le formattazioni introdotte per il metodo printf() della stessa classe. Ad esempio, per stampare a standard output un numero in virgola mobile con una impostazione locale italiana si scrive: import java.util.Locale; ... double d = 12.3; System.out.format(Locale.ITALY, "%f", d); ... INPUT import java.util.Scanner; import java.util.Locale; Scanner leggi = new Scanner (System.in); legge dati in ingresso dallo standart input (la tastiera), ricevuti attraverso l'oggetto System.in, creando un oggetto di tipo scanner in.useLocale (Locale.US); riconosce numeri formattati secondo diverse usanze locali in.close(); chiude l'oggetto di classe Scanner int num = in.nextInt(); acquisisce valori numerici interi da tastiera (l'acquisizione termina con invio) double num = in.nextDouble(); acquisisce valori numerici in virgola mobile da tastiera String s = in.next(); acquisisce da tastiera una parola (l'acquisizione termina con lo spazio o con invio) String s = in.nextLine(); acquisisce da tastiera una riga (l'acquisizione termina con invio) int age = Integer.parseInt(in.nextLine() ); String initials = nome.substring(0,1) + cognome.substring(0,1); String pw = initials.toLowerCase() + age;
PROGETTARE UNA CLASSE
Progettare la classe Stabilire quali sono le caratteristiche essenziali degli oggetti della classe, e fare un elenco delle operazioni che sarapossibile compiere su di essi: processo di astrazione Definire e scrivere l'interfaccia pubblica. Ovvero, scrivere l'intestazione della classe, definire i costruttori ed i metodi pubblici da realizzare, e scrivere la firma (specificatore di accesso, tipo di valore restituito, nome del metodo, eventuali parametri espliciti) di ciascuno di essi. Consiglio: se un metodo non restituisce valori (ovvero il tipo del valore restituito e void), scrivete inizialmente un corpo vuoto, ovvero {}. Se un metodo restituisce valori non void, scrivete inizialmente un corpo fittizio contenente solo un enunciato di return: ad esempio {return 0;} per metodi che restituiscono valori numerici o char, {return false;} per metodi che restituiscono valori booleani, {return null;} per metodi che restituiscono riferimenti ad oggetti. Con questi accorgimenti il codice compileracorrettamente fin dall'inizio del vostro lavoro. Quando poi scriverete i metodi, modificherete le istruzioni di return secondo quanto richiesto da ciascun metodo. Definire le variabili di esemplare ed eventuali variabili statiche. E necessario individuare tutte le variabili necessarie. Per ciascuna di esse si deve, poi, definire tipo e nome. Realizzare la classe Verificate le impostazioni del vostro editor di testi, al fine rendere piuefficiente il vostro lavoro di programmazione. In particolare, verificate ed eventualmente modificate le impostazioni per i rientri di tabulazione (valori tipici sono di 3 o 4 caratteri), e visualizzate i numeri di riga. A questo proposito si vedano anche i Consigli per la produttivita' 5.1 sul libro di testo) Scrivere il codice dei metodi. Consiglio: non appena si e realizzato un metodo, si deve compilare e correggere gli errori di compilazione (se il corpo del metodo eparticolarmente lungo e complicato, compilare anche prima di terminare il metodo). Non aspettate di aver codificato tutta la classe per compilare! Altrimenti vi troverete, molto probabilmente, a dover affrontare un numero elevato di errori, con il rischio di non riuscire a venirne a capo in un tempo ragionevole. **Collaudare la classe** Ovvero scrivere una classe di collaudo contenente un metodo main, all'interno del quale vengono definiti e manipolati oggetti appartenenti alla classe da collaudare. E possibile scrivere ciascuna classe in un file diverso. In tal caso, ciascun file avrail nome della rispettiva classe ed avra l'estensione .java. Tutti i file vanno tenuti nella stessa cartella, tutti i file vanno compilati separatamente, solo la classe di collaudo (contenente il metodo main) va eseguita. E` possibile scrivere tutte le classi in un unico file. In tal caso, il file .java deve contenere una sola classe public. In particolare, la classe contenente il metodo main deve essere public mentre la classe (o le classi) da collaudare non deve essere public (non serve scrivere private, semplicemente non si indica l'attributo public). Il file .java deve avere il nome della classe public METODI COSTRUTTORI E VARIABILI ESEMPLARI oggetto.nomeMetodo(parametri); invoca un metodo System.out.println(“abcd”); System.out.print(“abcd”); NomeClasse.nomeMetodo(parametri); invoca un metodo statico Un metodo statico elabora o modifica solo i propri parametri espliciti nomeIstanza.nomeMetodo(parametri); invoca un metodo non statico specificatoreDiAccesso tipoDatiRestituiti nomeMetodo (TipoParametro nomeParametro) {...} definisce un metodo (firma), costituita da SPECIFICATORE DI ACCESSO, TIPO DI DATI RESTITUITO, NOME DEL METODO, ELENCO DI PARAMETRI di cui si indica il tipo e il nome (eventualmente vuoto), più parametri sono separati dalla virgola. La firma è seguita dal corpo del metodo stesso, tra graffe. Ci sono metodi di accesso e metodi modificatori. public void println (String output) {...} public String replace (String target, String replace) {...} public static long round (double a) {...} public void deposit(double amount) {...} public double getBalance {...}
COLLAUDARE LA CLASSE
le classi di colaudo devono contenere un metodo main che deve essere public. Per scrivere più classi nello stesso file chiamo solo una classe public: la classe col main (le altre sono private ma non serve indicarlo, semplicemente non si scrive). Il file deve chiamarsi come la classe col main. //APRIRE UN NUOVO CONTO E DEPOSITARE DENARO double initialDeposit = 1000; BankAccount account = new BankAccount(); account.deposit(initialDesposit); System.out.println(“saldo: “ + account.getBalance() ); //FARE UN BONIFICO double amount = 500; account1.withdraw(amount); //ACCREDITARE INTERESSI double rate = 0.05; double amount = account.getBalance()*rate; account.deposit(amount);
CONFRONTO TRA NUMERI IN VIRGOLA MOBILE
final double EPSILON = 1E-14; if (Math.abs(x-y) <=EPSILONMath.max(Math.abs(x), Math.abs(y)) )* ... verifica l'uguaglianza tra x e y di tipo double (10^-14 è un valore di differenza ragionevole tra numeri double (il loro confronto deve prevedere una tolleranza. Math.max(|x|,|y|) lo uso se x e y molto grandi o molto piccoli). Posso anche definire un metodo statico che verifichi l'uguaglianza con tolleranza (in un solo file): import java.util.Scanner; public class ConfrontoDouble { static class Comparator { public static boolean approxEqual (double x1, double x2, int digits) { double scale = Math.pow (10, digits); return Math.round(scalex1) == Math.round(scalex2); } } public static void main (String [] args) { Scanner in = new Scanner (System.in); System.out.println("scrivi due numeri double"); double x1 = in.nextDouble(); double x2 = in.nextDouble(); final int digits = 2; String negation = " non"; if (Comparator.approxEqual(x1,x2,digits)) negation = ""; System.out.println(x1 + " e " + x2 + negation + " sono approssimativamente uguali"); } } le parti in blu possono essere omesse (in questo caso approxEqual fa riferimento alla sua classe).
CONFRONTO STRINGHE (e OGGETTI)
Per comparare due stringhe non si usa == ma un metodo (equals) if ( s1.equals(s2) ) restituisce true o false if ( s1.equalsIgnoreCase(s2) ) confronta s1 e s2 ignorando maiuscole e minuscole se uso == (non è un errore di sintassi) il risultato del confronto sembra essere casuale. Per verificare se un oggetto si riferisce a null uso == if (s1==null) restituisce true o false if ( s1.compareTo(s2) <0) fa un confronto lessicografico tra s1 e s compareTo restituisce un valore NEGATIVO se s1 precede s2, un valore POSITIVO se s segue s2, 0 se s1 e s2 sono identiche. I numeri precedono le lettere. Le maiuscole precedono le minuscole. Lo spazio precede tutto. Il metodo equals può essere applicato a qualsiasi oggetto (perchè è definito nella classe Object) ma è compito di ciascuna classe ridefinire il proprio metodo equals poiché esso prevede il confronto delle caratteristiche (=variabili esemplare) degli oggetti specifici della classe. CompareTo non è definito in Object quindi può essere usato per molti oggetti ma non per tutti.
ESPRESSIONI BOOLEANE
ogni espressione relazionale (<<= ecc) ha un valore booleano (true o false). Essi appartengono ad un tipo di dati fondamentale detto “booleano”. Le variabili booleane possono assumere solo i valori TRUE o FALSE per questo a volte vengono chiamate FLAG. Int x; ... a = x>0; i metodi che restituiscono valori di tipo booleano vengono chiamati METODI PREDICATIVI e solitamente verificano una condizione sullo stato di un oggetto (iniziano con “is” oppure “has”). I metodi predicativi possono essere ustati come condizioni di enunciati if. Character .is Digit(ch), Character.isLetter(ch), Character.isUpperCase(ch), Character.isLowerCase(ch) .has NextInt, .hasNextDouble Gli operatori booleani sono! (not) && (and) || (or) in ordine di precedenza. La valutazione di un'espressione con operatori booleani viene effettuata con la strategia del cortocircuito (o valutazione pigra ) ovvero la valutazione di un'espressione termina appena è possibile decidere il risultato. TRUE or qualcosa è sempre TRUE.
CONDIZIONI E CICLI/ITERAZIONI
IF
if (condizione) { enunciati; } else { enunciati; } Una clausola else appartiene sempre all'if più vicino. Una variabile, se dichiarata dentro l'if, è visibile solo all'interno dell'if. LA VISIBILITA' DI VARIABILI LOCALI E' INTERNA AL BLOCCO IN CUI SONO DEFINITE SWITCH confronta un'unica variabile con diverse alternative costanti int x; int y; ... switch (x) { case 1 : y=1; break; case 2: y=9; break; ... case default : y=4; break; }
IL PROBLEMA DEL CICLO E MEZZO
boolean done = false; while (!done) //ciclo e mezzo { System.out.println("Inserire numero (Q per terminare sequenza):"); String newInput = in.next(); if (newInput.equalsIgnoreCase("Q")) done = true; else // aggiorniamo la somma, la somma dei quadrati, il contatore { double value = Double.parseDouble(newInput); sum += value; sumSquares += value * value; count++; } } Soluzione alternativa alla struttura “ciclo e mezzo”:
- usare un ciclo infinito while(true) e l’enunciato break L’enunciato break provoca la terminazione del ciclo. Esiste anche l'enunciato continue, che fa proseguire l'esecuzione dalla fine dell'iterazione attuale del ciclo.
PARAMETRI DEI METODI
public void deposit (double amount ) { balance = balance + amount; } In questo caso amount è il parametro esplicito del metodo. Balance si riferisce alla variabile di esemplare balance della classe BankAccount di cui esiste una copia per ogni oggetto della classe (ma alla variabile balance di quale oggetto si riferisce il metodo?). Si riferisce alla variabile che appartiene all'oggetto con cui viene invocato il metodo. account.deposit(500); all'interno di ogni metodo il riferimento all'oggetto con cui viene eseguito il metodo si chiama parametro implicito e si indica con la parola “this”. Ogni metodo ha solo un parametro implicito (i metodi statici non hanno parametro implicito). Il parametro implicito non deve essere dichiarato e si chiama sempre this. Public void deposit (double amount) { this.balance = this.balance + amount; } la parte blu posso non metterla this è di tipo BankAccount. Se un metodo si riferisce ad un campo di esemplare il compilatore costruisce automaticamente un riferimento al campo di esemplare dell'oggetto raprresentato dal parametro implicito this. CLASSI DI UTILITA' sono classi che non servono a creare oggetti ma che contengono metodi statici (es: classe Math) Spesso servono variabili condivise da tutti gli oggetti di una classe (le variabili di esemplare sono copiate in ogni oggetto, quindi ogni oggetto può averne un valore diverso). Queste si chiamano VARIABILI STATICHE o VARIABILI DI CLASSE (non devono essere inizializzate nei costruttori ma fuori.
VARIABILI STATICHE
private static int lastAssignedNumber; crea una variabile statica. Ogni metodo o costruttore di una classe può accedere alla variabile statica e modificarla (di variabile statica ce n'è una sola, di variabile esemplare ce ne sono più copie). public class BankAccount { ... private int accountNumber; //modifica BankAccount in modo che contenga un numero di conto private static int lastAssignmentNumber = 0; //inizializzata fuori dal costruttore ... public BankAccount() { lastAssignmentNumber++; //ogni oggetto ha il numero di conto incrementato di uno accountNumber = lastAssignmentNumber; } } Se lastAccountNumber non fosse dichiarata static, ogni istanza di BankAccount avrebbe il proprio valore di lastAssignmentNumber. public static final double PI=3.14... COSTANTE STATICA nella classe Math
CICLO DI VITA DELLE VARIABILI
- VARIABILE LOCALE
● creata quando viene eseguito l'enunciato in cui è definita ● eliminata quando l'esecuzione del programma esce dal blocco di enunciati in cui la variabile è definita ● se non è definita in un blocco di enunciati viene eliminata quando l'esecuzione del programma esce dal metodo in cui è definita
- VARIABILE PARAMETRO (quelle che passiamo come parametro dei metodi) ● creata quando viene invocato il metodo ● eliminata quando l'esecuzione del metodo termina
- VARIABILE DI ESEMPLARE ● creata quando la JVM carica la classe per la prima volta ● eliminata quando la JVM scarica la classe (=rimane sempre..)
- VARIABILE STATICA ● creata quando viene creato l'oggetto ● eliminata quando viene eliminato l'oggetto, ovvero quando non esiste più nessun riferimento ad esso nel programma (memoria periodicamente riciclata = garbage collection)
MEMORIA
al momento dell'esecuzione a ciascun programma java viene assegnata un'area di memoria
- AREA STATICA memorizzare il codice
- JAVA STACK (=pila) area dinamica (cambia dimensione durante l'esecuzione) in cui vengono memorizzati i parametri e le variabili locali che vengono create man mano
- JAVA HEAP (=cumulo) area dinamica in cui vengono creati oggetti durante l'esecuzione dei metodi (con new)
COESIONE ED ACCOPPIAMENTO
Metodi pubblici e costanti elencati nell'interfaccia pubblica devono avere una buona coesione ovvero devono essere strettamente correlate al singolo concetto rappresentato dalla classe. Le classi accoppiate (quando una classe nel proprio codice usa un'altra classe) sono dipendenti, bisogna eliminare tutti gli accoppiamenti non necessari perchè se una classe viene modificata anche tutte quelle da cui dipende potrebbero richiedere modifiche. EFFETTI COLLATERALI E' l'effetto di un metodo, osservabile fuori dal metodo. Qualsiasi metodo modificatore ha effetti collaterali (modificano il proprio parametro implicito), altri metodi possono modificare il parametro esplicito. Un altro effetto collaterale è la visualizzazione di dati in uscita.
PACCHETTI
import nomePacchetto.NomeClasse; import nomePacchetto.;* per importare tutte le classi di un pacchetto se una classe appartiene a più di due pacchetti importati il compilatore da errore (riferimento ambiguo) quando uso un metodo della classe o un costruttore devo indicare il nome completo della classe (es: java.math.BigInteger a = new java.math.BigInteger(“123456”); )
PRECONDIZIONI
come deve reagire un metodo se riceve un parametro che non rispetta i requisiti richiesti (=PRECONDIZIONI)?
- Potrei eseguire solo se le precondizioni sono esatte, ma questo va bene solo per metodi con valori di ritorno void, se restituisce un valore casuale senza segnalare errore è un problema 2)potrei terminare il programma con System.exit(1), System.exit(0) termina l'esecuzione segnalando che tutto è andato bene. Si usa soltanto in programmi non professionali 3)potrei usare un asserzione, ma si usa soltanto per programmi in fase di sviluppo e collaudo 4)potrei LANCIARE UN'ECCEZIONE
ECCEZIONI
GESTIONE ECCEZIONI
Le eccezioni in java sono OGGETTI che non è necessario memorizzare. Ci sono molte classi di eccezioni. Il meccanismo di lancio e cattura delle eccezioni permette di gestire un errore di esecuzione in un punto diverso rispetto a dove questo si è generato. “lanciare presto, catturare tardi” Quando un metodo incontra un problema che non è in grado di gestire meglio conviene lanciare un'eccezione. Quando un metodo riceve un'eccezione lanciata da un altro metodo conviene catturarla solo se si è in grado di risolvere bene il problema altrimenti è meglio propagarla fino al main. throw oggettoEccezione; di solito l'oggetto eccezione viene creato con new ClasseEccezione() public void deposit (double amount) { if (amount <=0) throw new IllegalArgumentException(); balance = balance + amount; }
In questo caso il programma non è detto che termini. Viene interrotta l'esecuzione del metodo, l'eccezione viene propagata al metodo chiamante (potrebbe essere anche il main) la cui esecuzione viene a sua volta interrotta. L'eccezione viene via via propagata fino al main e ciò provoca l'arresto anormale del programma con segnalazione dell'eccezione. Bisogna gestire le eccezioni, per non farle arrivare al main. I metodi che servono a gestire le eccezioni (che potebbero sollevarle) vanno racchiusi in un blocco TRY {} seguito da catch (che le cattura). try { enunciati che forse generano una o più eccezioni } catch (ClasseEccezione1 nomeOggetto1) { enunciati eseguiti in caso di eccezione1 } catch (ClasseEccezione2 nomeOggetto2) { enunciati eseguiti in caso di eccezione2 } Se per esempio voglio risolvere il problema di convertire in fomato numerico una stringa, se la stringa non contiene un numero valido viene generata un'eccezione NumberFormatException try{ ... n = Integer.parseInt(line; ... } il blocco try è seguito da una o più clausole CATCH che catturano l'eccezione. Definita in modo simile ad un metodo riceve un solo parametro del tipo dell'eccezione che si vuole gestire catch(NumberFormatException e) // la “e” è il nome del parametro { System.out.println(“messaggio”); } l'eccezione non si propaga più al main ma esegue il catch. Nel catch ci sono le istruzioni che devono essere eseguite nel caso in cui si verifichi l'eccezione. L'esecuzione del blocco try viene interrotta nel punto in cui si verifica l'eccezione e non viene più ripresa. E se il metodo con più precondizioni genera più eccezioni? Devo scrivere più catch perchè eccezioni diverse vanno gestite il modo diverso public static void main { System.out.println(“scrivi un int”); ... int n=0; boolean done = false; while (!done) { try { String line = in.nextLine(); n= Integer.parseInt(line); //l'asseganzione viene eseguita solo se non viene lanciata l'eccezione done=true; } catch (NumberFormatException e) { System.out.println(“no devi inserire un int”); //all'uscita del blocco catch done è false, quindi l'utente lo reinserisce } } System.out.println(“si è un numero int”); }
PROPAGARE ECCEZIONI DI IO
un metodo può non gestire un'eccezione controllata e propagarla: il metodo termina la propria esecuzione e lancia la gestione al metodo chiamante. Per dichiarare che un metodo propaga un'eccezione controllata, si contrassegna il metodo con il marcatore throws throws nome1, nome public class InputReader { public void read (String filaname) throws IOException { String filaname = “filename.txt”; FileReader reader = new FileReader (filename); Scanner in = new Scanner (reader); } } Se avessi scritto public void read (String filaname) throws FileNotFoundException il metodo read non avrebbe gestito le eccezioni FileNotFoundException (lo deve dichiarare con throws). Se non si vuole gestire un'eccezione controllata si può dichiarare che il metodo main la propaga il programma si blocca ma compila import java.io.FileNotFoundException; import java.io.FileReader; import java.util.Scanner; ... public static void main (String [] args) throws IOException { String filaname = “filename.txt”; FileReader reader=new FileReader (filename); Scanner in = new Scanner (reader); } ECCEZIONI DI SCANNER Scanner è una classe di utilità. NON lancia eccezioni di IO. NoSuchElementException (lanciata da next e nextLine se l'input non è disponibile) InputMismatchException (lanciata da nextInt e nextDouble) IllegalStateException (lanciata dai metodi se invocati quando lo scanner è chiuso) MEGLIO USA NEXT() E NEXTLINE() E POI CONVERTIRE CON DOUBLE.PARSEDOUBLE ECCEZIONI IN INPUT Cosa succede se l'esecuzione viene interrotta da un'eccezione prima dell'invocazione del metodo close? Si verifica una situazione di potenziale instabilità. Si può usare la clausola finally. Il corpo di una clausola finally viene eseguito comunque, indipendentemente dal fatto che un'eccezione sia stata generata oppure no. FileReader reader = new FileReader (filename); try { Scanner in = new Scanner (reader); readData(in); } finally { reader.close();} L'istruzione contenuta nel blocco finally viene eseguita comunque prima di passare l'eccezione al suo gestore ( se non avessi messo finally potrebbe essere che non si arrivi mai al close se viene generata un'eccezione).
LEGGERE E SCRIVERE SU FILE
LEGGERE DA UN FILE DI TESTO
La gestione dei file avviene interagendo con il sistema operativo mediante classi del pacchetto java.io. Per farlo: 1)creo un oggetto lettore di file (FileReader) 2)creo un oggetto Scanner 3)collego l'oggetto Scanner al lettore di file FileReader reader = new FileReader(“input.txt”); //apre il file in lettura Scanner in = new Scanner (reader); ... reader.close(); Possiamo usare next e nextLine per leggere da file. Volendo ci sono anche i metodi di FileReader. while(in.hasNextLine() ) //fino a che il file non è finito (metodo predicativo, ritorna boolean) { String line = in.nextLine(); //sono sicuro di non sollevare eccezione perche viene eseguito solo se la riga effettivamente c'è //elaborazione stringa } Il costruttore FileReader lancia IOException (da gestire!!). Il metodo close() lancia IOException (da gestire!!). SCRIVERE SU UN FILE DI TESTO 1)creare un oggetto scrittore PrintWriter 2)collegare l'oggetto PrintWriter ad un file PrintWriter out = new PrintWriter(“output.txt”); ... out.close(); se output.txt non esiste viene creato, se esiste già viene svuotato prima di essere scritto. Per aggiungere scritte in coda ad un file già scritto: FileWriter writer = new FileWriter(“file.txt”), true); PrintWriter out = new PrintWriter (writer); BISOGNA SEMPRE CHIUDERE UN OGGETTO PRINTWRITER DOPO AVER FINITO DI USARLO Per RILEVARE LA FINE DELL'INPUT posso usare q (ciclo e mezzo), hasNext() o hasNextLine() (restituiscono false quando il file è terminato). Import java.io.FileReader; Import java.io.IOException; Import java.io.PrintWriter; Import java.util.Scanner; public class LineNumberer { public static void main (String [] args) { Scanner console = new Scanner (System.in); System.out.print(“input file: “); String inputFileName = console.nextLine(); System.out.print(“output file: “); String outputFileName = console.nextLine();
SCOMPOSIZIONE DI STRINGHE
Una sottostringa delimitata da caratteri speciali (delimitatori) si chiama TOKEN o LESSEMA. Scanner considera come delimitatori i caratteri spazio, tab, a capo. Per scomporre una stringa in token usando scanner: 1)creare un oggetto dellla classe fornendo la stringa come parametro al costruttore Scanner in = new Scanner (System.in); String line =in.nextLine(); Scanner t = new Scanner (line); 2)successive invocazioni del metodo next restituiscono successive sottostringhe, fin quando hasNext restituisce true while(t.hanNext() ) { String token = t.next(); //elabora token import java.util.Scanner; public class TokenCounter { public static void main (String [] args) { Scanner in = new Scanner (System.in); int count = 0; while (in.hasNextLine() ) { String line = in.nextLine(); Scanner t = new Scanner (line); while(t.hanNext() ) { t.next(); count ++; } } } } Student[] studenti = new Student[3]; while (count <3) { Scanner in = new Scanner(System.in); //CLOSE THE SCANNER String line = in.nextLine(); if (line.equals(“”)) break; Scanner s = new Scanner (line); //CLOSE THE SCANNER studenti[count++] = new Student (s.next(), s.next(), s.nextDouble(), s.nextDouble() ); } for (int i =0; i<count; i++) System.out.println(“\n” + studenti[i].nameInput + studenti[i].surnameInput + ... ); Nei Token per cambiare il delimitatore posso usare. useDelimiter(...) String input = “1 fish 2 fish 3 fish” // \s* significa 0 o più ripetizioni delo spazio bianco, fish è il pattern da trovare Scanner s = new Scanner (input).useDelimiter(“\sfish\s”); System.out.println(s.next() ); // stampa 1 System.out.println(s.next() ); // stampa 2 System.out.println(s.next() ); // stampa 3
REINDIRIZZAMENTO DI INPUT E OUTPUT
System.in non è più tastiera ma, per esempio un file. Per far ciò quando eseguo devo scrivere < per l'input e > per l'output. java NomeClasse < testo.txt > output.txt Il file testo.txt viene collegato all'input standard. Il programma è scritto per esempio cosi: ... Scanner in = new Scanner (System.in); while (in.hasNext() ) System.out.println(in.next() ); .... CANALIZZAZIONI (“PIPES”) sort<temp.txt<testoOrdinato.txt ma invece di usare un file temporaneo posso usare una canalizzazione: java NomeFile < testo.txt | sort > testoOrdinato.txt java NomeFile < testo.txt | sort | wc
FLUSSO DI ERRORE STANDARD
java ha due flussi standard (System.in e System.out). Ma esiste anche il flusso di errore standard (System.err) che è di tipo PrintStream. La differenza tra out e err è che: -out si usa per comunicare i risultati dell'eleborazione o dei messaggi -err si usa per comunicare condizioni di errore System.err.println(“ERRORE!!”); lo standard error può essere indirizzato in un altro file rispetto alla standard output. C:> java HelloTester > out.txt 2> err.txt
