Modificatori. Controllo di visibilità

Transcript

1 Modificatori I modificatori (modifiers) sono prefissi da applicare in diverse combinazioni a metodi, variabili ed alle classi stesse. L ordine in cui specificare i modificatori è irrilevante, ma è consigliato l ordine seguente: <access> static abstract synchronized <unusual> final native <access> permette di definire il controllo dell accesso <unusual> (che può assumere uno dei valori volatile e transient)esynchronized definiscono caratteristiche legate al multithreading native specifica che un metodo è implementato in un linguaggio nativo (di solito il linguaggio C) Nessuno modificatore è obbligatorio ma è buona norma specificarli tutte le volte che si intende chiarire l uso o le restrizioni applicate a variabili, metodi e classi. : APPROFONDIMENTI 1 Controllo di visibilità Quando un metodo Ñ o una variabile Ú sono visibili da una classe diversa da quella in cui sono definiti, i metodi della classe possono chiamare il metodo Ñ o modificare la variabile Ú. µ Il controllo della visibilità di metodi e variabili acquista sempre maggiore importanza a mano a mano che il programma cresce in complessità. Il modificatore <access> permette di controllare la visibilità. Può assumere uno dei seguenti valori: public package protected private Ciascuno dei quattro livelli di protezione p èpiù restrittivo del precedente. : APPROFONDIMENTI 2

2 Controllo di visibilità Il modificatore public fornisce il livello massimo di visibilità di variabili, metodi e classi: chiunque può utilizzarle o modificarle. Il modificatore package (in realtà oggi sostituito dall assenza di modificatori e quindi non più esistente) rende visibili variabili e metodi all interno del gruppo di classi appartenenti allo stesso package. È il modificatore di default. Se una classe appartenente ad un package fa riferimento ad un metodo o variabile con modificatore di default in un package diverso, genera un errore di compilazione. : APPROFONDIMENTI 3 Il modificatore protected Spesso le sottoclassi sono più legate alla superclasse di qualsiasi altra classe, perché le sottoclassi hanno necessità di accedere alle strutture dati interne delle loro superclassi le sottoclassi spesso devono modificare o migliorare la rappresentazioni dei dati delle superclassi le sottoclassi sono spesso scritte da persone che accedono al codice sorgente delle superclassi Il modificatore protected limita la visibilità di variabili e metodi alle sottoclassi della classe corrente. µ Permette di supportare l astrazione dei dati in modo semplice : APPROFONDIMENTI 4

3 Esempio: modificatore protected Il seguente esempio evidenzia l importanza del modificatore protected per garantire l astrazione. public class List { protected BinaryTree thebinarytree; public Object[] thelist() { return thebinarytree.asarray(); public class SortedList extends List { public void insertinorder(object o) { thebinarytree.insertobject(o); public void add(object o) { thebinarytree.addobject(o); L unica possibilità di accesso esterno è mediante il metodo thelist(), che ritorna un array di oggetti. µ Senza la conoscenza della variabile BinaryTree il metodo insert dovrebbe agire sull array. µ Poiché BinaryTree è dichiarata protected, il metodo insert può invece inserire nella lista sfruttando la nozione di albero binario. Dall esterno il fatto che la lista sia ordinata mediante un albero binario è del tutto invisibile. : APPROFONDIMENTI 5 Il modificatore private Il modificatore private rende variabili e metodi visibili solo all interno della classe in cui sono definiti. Tutti i dati che rappresentano stati interni alla classe o dati privati devono essere dichiarati private. Il modificatore private permette di incapsulare i dati nel modo migliore. Non è possibile specificare separatamente livelli di protezione in scrittura e lettura µ la dichiarazione private evita che altre classi possano modificare variabili di istanza µ una variabile di istanza (a meno che non sia una costante) dovrebbe sempre essere dichiarata private Un eccezione è costituita dalla variabile out che viene utilizzata nel metodo System.out.print(), che per ovvi motivi deve essere pubblica. : APPROFONDIMENTI 6

4 Visibilità delle variabili di istanza Per permettere la visibilità esterna delle variabili di istanza si dichiara private la variabile di istanza si definisce un metodo di accesso in lettura public si definisce un metodo di accesso in scrittura protected In questo modo µ È possibile separa la variabile stessa dalla sua visibilità in lettura e scrittura. µ È possibile modificare l implementazione della variabile senza dover riscrivere il metodi che la utilizzano. public class ACorrectClass { private String ausefulstring; public String get_ausefulstring () { return ausefulstring; protected String set_ausefulstring (String s) { ausefulstring s; Per modificare la variabile si usa la notazione set ausefulstring ( get ausefulstring() + " testo aggiunto"); Tale notazione corrisponde a scrivere x(12+5*x()); invece di x = 12+5*x; : APPROFONDIMENTI 7 Il modificatore final Il modificatore final se applicato ad una classe, indica che non è possibile creare sottoclassi di tale classe se applicato ad una variabile, indica che tale variabile è una costante se applicato ad un metodo, indica il metodo non può essere ridefinito dalle sottoclassi Il motivo principale per dichiarare una classe final è impedire che istanze di tale classe create da altre sottoclassi siano presenti nel sistema, normalmente per motivi di sicurezza o di efficienza. Le variabili final devono essere inizializzate al momento della loro dichiarazione. Si comportano come una versione tipata del costrutto #define del linguaggio C. public class AnotherCLass { public static final int aconstantint = 123; public final String aconstantstring = "Hello world"; : APPROFONDIMENTI 8

5 Il modificatore final I metodi final non possono essere ridefiniti. µ il compilatore ha la garanzia che tali metodi non potranno essere modificati da nessuno µ il compilatore può inserire direttamente il codice del metodo all interno dei metodi che lo chiamano µ associare il modificatore final ad un metodo permette di ottenere un esecuzione più efficiente Questa tecnica può essere utilizzata per rendere più efficienti i metodi che garantiscono l accesso a variabili di istanza. Tutti i metodi che appartengono ad una classe final oppure che sono private sono automaticamente final. : APPROFONDIMENTI 9 Il modificatore abstract Le classi ai livelli più alti di una gerarchia di generalizzazione sono più generali, mentre quelle ai livelli più bassi sono più specifiche. Spesso la creazione di una superclasse è utilizzata per specificare comportamenti comuni a molte classi. µ Si definisce una classe astratta, specificando il modificatore abstract. Le classi abstract non possono essere istanziate (a parte ciò sono del tutto uguali alle altre classe) sono le sole che possono contenere metodi abstract (di cui è specificata solo l interfaccia), oltre ai metodi normali public abstract class LaMiaPrimaClasseAstratta { int instancevariable; public abstract int UnMetodoCheLeSottoClassiDevonoRealizzare();... public int UnMetodoNormale() { : APPROFONDIMENTI 10

6 Il modificatore abstract Le sottoclassi devono definire l implementazione dei metodi abstract delle loro superclassi. public class SottoClasseConcreta extends LaMiaPrimaClasseAstratta { public int UnMetodoCheLeSottoClassiDevonoRealizzare() {... Object a = new LaMiaPrimaClasseAstratta(); // Illegale! Object a = new SottoClasseConcreta(); // OK L uso di una classe astratta che contenga solamente metodi astratti non è scorretto; è preferibile però utilizzare le interfacce per ottenere lo stesso scopo. : APPROFONDIMENTI 11 Package I package sono utilizzati in Java sia per categorizzare sia per raggruppare classi tra loro. Per creare un package è sufficiente scrivere nella prima linea nel file: package ilmioprimopackage; Se l istruzione package non è presente in un file, il codice fa parte di un package senza nome di default. I package possono essere organizzati in modo gerarchico. package ilmioprimopackage.packageinterno; Ad esempio, le librerie Java sono organizzate in un package di primo livello: java package di secondo livello: java.io, java.net, java.util, java.applet, java.lang e java.awt. Di norma i package sono caratterizzati da un nome con lettera iniziale minuscola; le classi preferenzialmente iniziano con una lettera maiuscola. : APPROFONDIMENTI 12

7 Nomi dei package Per garantire l unicità dei nomi dei package, si utilizza una tecnica di definizione dei nomi basata sull organizzazione logica in domini di Internet e sull indirizzo (Internet) della società che sviluppa il package. COM.sun.java.io EDU.harvard.cs.project.ai.learning.myPackage L organizzazione gerarchica dei package deve riflettersi in una analoga organizzazione dei direttori in modo tale che il compilatore sappia sempre dove trovare i file necessari: le classi sono cercate a partire dal path specificato nella variabile di ambiente CLASSPATH ogni file può contenere una sola classe public Ad esempio, per il sistema operativo Unix, la classe java.awt.image.colormodel si trova in un file ColorModel.class in.../classes/java/awt/image. : APPROFONDIMENTI 13 L istruzione import Ogni riferimento ad una classe in un programma java è composto da una parte (implicita o esplicita) che identifica il package a cui la classe appartiene. Per semplificare la notazione ed evitare di scrivere per esteso il nome di ogni classe è possibile importare packages (eventualmente utilizzando la wildcard * ) con il comando import. import package; import package.class; import package.*; Il comando import deve essere specificato all inizio del file, subito dopo l istruzione (opzionale) package e prima di qualsiasi definizione di classe o interfaccia. Può essere specificato un numero arbitrario di comandi import. Il comando import non copia le classi; permette soltanto di specificare il nome delle classi senza la loro estensione completa. : APPROFONDIMENTI 14

8 L istruzione import Possono essere importate solo le classi pubbliche, non quelle definite ad esempio con il modificatore package, il modificatore di default. Eventuali classi non visibili direttamente ma necessarie al funzionamento di classi visibili importate saranno ovviamente caricate dal compilatore, ma resteranno non disponibili in accesso esplicito alle altre classi. L istruzione import java.lang.* è implicita. L istruzione import pack1.* importa tutte le classi contenute in pack1, ma non quelle contenute nei package gerarchicamente al di sotto di pack1. : APPROFONDIMENTI 15 Interfacce Le interfacce sono analoghe alle classi astratte perché forniscono lo schema di metodi (non il codice) che altre classi implementeranno sono diverse dalle classi astratte perché non possono contenere né implementazioni di metodi, né definizioni di variabili di istanza Le interfacce possono essere implementate da una classe, che fornisce la definizione del corpo di tutti i metodi specificati nell interfaccia. Permettono di realizzare l ereditarietà multipla, più complessa dell ereditarietà semplice. : APPROFONDIMENTI 16

9 Interfacce La dichiarazione di una interfaccia è molto simile a quella di una classe. public interface LaMiaInterfaccia { public static final int theanswer = 42; public abstract int metodopazzo(); long contatoreditutto = 0; // Diventa public, static, final (costante) long etadelluniverso(); // Diventa public, abstract protected int unacostante: // VIETATO private int altracostante; // VIETATO Tutti i metodi sono public e abstract. Tutte le variabili sono public, static, final, cioè sono costanti. Interfacce e classi hanno le stesse caratteristiche; le interfacce però non sono istanziabili mediante il comando new. : APPROFONDIMENTI 17 Interfacce ed ereditarietà multipla Le classi in Java possono avere una sola superclasse µ i comportamenti globali definiti da una classe astratta possono essere ereditati solo dalle sue sottoclassi Le classi in Java possono implementare un numero arbitrario di interfacce µ l ereditarietà dei comportamenti globali definiti da un interfaccia non è vincolata da una gerarchia di classe µ Le interfacce permettono di realizzare l ereditarietà multipla di metodi. : APPROFONDIMENTI 18

10 Interfacce: un esempio Supponiamo esistano due classi, la classe Frutto e la classe OggettiSferici. La classe Arancia è sicuramente una sottoclasse di Frutti, ma ci piacerebbe che condividesse lo stesso comportamento della classe OggettiSferici. interface TuttaLaFrutta extends TuttoIlCibo { void si_decompone(); void si_schiaccia();... interface OggettiSferici { void sigira();... class Frutto extends Cibo implements TuttaLaFrutta { private Color ilcolore; private int giorniprimachesidecomponga;... class Arancia extends Frutto implements OggettiSferici {... // eredito da Frutto la... // realizzazione di TuttaLaFrutta Nel momento in cui si renda disponibile una classe Sfera, è possibile modificare la definizione di Arancia senza modificare la sua visibilità dall esterno. class Sfera implements OggettiSferici { private float raggio;... class Arancia extends Sfera implements TuttaLaFrutta {... : APPROFONDIMENTI 19 Gerarchie di interfacce In parallelo e indipendentemente dalla gerarchia delle classi, è possibile definire una gerarchia di interfacce, con la differenza che non esiste una superclasse comune a tutte le interfacce come la classe Object. public interface LaMiaSecondaInterfaccia extends Interfaccia1, Interfaccia2 {... public class LaMiaClasse implements LaMiaSecondaInterfaccia {... L interfaccia LaMiaSecondaInterfaccia eredita tutti i metodi e le costanti di Interfaccia1 edi Interfaccia2. La classe LaMiaClasse deve definire il corpo di tutti i metodi definiti nell interfaccia LaMiaSecondaInterfaccia e in tutte le sue superinterfacce (Interfaccia1 e Interfaccia2). : APPROFONDIMENTI 20

11 Eccezioni L eccezione è una istanza della classe Throwable che permette la gestione degli errori e di eventi imprevisti. Le eccezioni permettono di esprimere in modo esplicito, mediante la clausola throws, quali eventi eccezionali (normalmente errori) un metodo oppure una classe può creare. public class LaMiaPrimaClasse { public void unmetodoconeccezioni() throws LaMiaPrimaEccezione {... Se voglio creare una eccezione: public class LaMiaPrimaClasse { public void unmetodoconeccezioni() throws LaMiaPrimaEccezione {... if (qualcosaditerribilesuccede() ) { throw new LaMiaPrimaEccezione(); // questa parte di codice non viene mai eseguita : APPROFONDIMENTI 21 Esempio di passaggio di eccezioni tra metodi. Eccezioni public void unaltrometodoconeccezioni() throws LaMiaPrima Eccezione { LaMiaPrimaClasse almpc = new LaMiaPrimaClasse(); almpc.unmetodoconeccezioni(); Poiché all interno del metodo unaltrometodoconeccezioni() non gestisco l eccezione LaMiaPrimaEccezione, che potrebbe essere creata dal metodo unmetodoconeccezioni(), devo passare tale eccezione ai metodi che mi hanno chiamato mediante la clausola Throws. Se voglio gestire all interno di un metodo una eccezione senza passarla ai metodi chiamanti uso le istruzioni try e catch: public void unmetodoresponsabile() { LaMiaPrimaClasse almpc = new LaMiaPrimaClasse(); try { almpc.unmetodoconeccezioni(); catch (LaMiaPrimaEccezione m) {... // eseguire codice particolarmente intelligente : APPROFONDIMENTI 22

12 Eccezioni Se voglio gestire una eccezione ma passarla comunque ai metodi chiamanti: public void unmetodoresponsabile() throws LaMiaPrimaEccezione { LaMiaPrimaClasse almpc = new LaMiaPrimaClasse(); try { almpc.unmetodoconeccezioni(); catch (LaMiaPrimaEccezione m) {... // eseguire codice particolarmente intelligente throw m; Poiché le eccezioni sono una classe, esiste anche una gerarchia di eccezioni. La classe Throwable ha due sottoclassi: Exception e Errors. La classe RunTimeException è a sua volta una sottoclasse della classe Exception. : APPROFONDIMENTI 23 Eccezioni Non è necessario dichiarare le istanze delle classi Error e RunTimeException con la clausola throws poiché si riferiscono ad eventi non causati direttamente dal programma, ma che si possono verificare in qualunque momento. Esempio: OutOfMemoryError. Esempi di eccezioni dichiarabili in una clausola throws: ClassNotFoundException, InstantiationException, NoSuchMethodException. La gestione delle eccezioni spesso si basa su strutture del tipo: try { unmetodoconeccezioni(); catch (NullPointerException n) { // una sottoclasse di RuntimeException... // gestisco la NullPointerException catch (RunTimeException r) { // una sottoclasse di Exception... // gestisco le RunTImeExceptions... // che non sono NullPointerException catch (IOException i) { // una sottoclasse di Exception... // gestisco le IOExcetion catch (LaMiaPrimaEccezione m) { // la mia sottoclasse di Exception... catch (Exception e) {... throw m; : APPROFONDIMENTI 24

13 La clausola finally La clausola finally permette di specificare azioni che devono sempre essere eseguite, anche se si verifica un tipo qualsiasi di eccezione (per esempio rilasciare una risorsa esterna o chiudere un file). MioFile f = new MioFile(); if (f.open("pippo")) { try { metodoeccezionale(); finally { f.close() Il programma precedente si comporta in modo analogo a questo: MioFile f = new MioFile(); if (f.open("pippo")) { try { metodoeccezionale(); catch (Throwable t) { f.close(); throw t; : APPROFONDIMENTI 25 Gestione I/O La gestione dell I/O in Java è basata sul concetto di stream. Una stream è un percorso di comunicazione tra l origine di un informazione e la sua destinazione. L informazione può provenire da qualsiasi origine: la memoria del calcolatore, un file, Internet. La sorgente è un produttore arbitrario di dati (per esempio byte). La destinazione è un consumatore arbitrario di dati (per esempio byte). Il package java.io contiene la maggior parte delle classi che permettono di gestire l I/O in Java è java.io. Quasi tutte le stream (oltre 60) derivano da quattro classi astratte principali: InputStream e OutputStream per la gestione dell I/O di stream di byte Reader e Writer per la gestione dell I/O di stream di caratteri (Unicode) Tutti i metodi che gestiscono l I/O generano eccezioni appartenenti alla classe IOException (sottoclasse di Exception), che include tutti gli errori di I/O che possono avvenire leggendo o scrivendo stream. : APPROFONDIMENTI 26

14 La gerarchia delle classi in java.io (1/2) Object InputStream File RandomAccessFile StreamTokenizer OutputStream ByteArrayIS FileIS FilterIS PipedIS SequenceIS StringBufferIS ByteArrayOS FileOS FilterOS PipedOS BufferedIS DataIs LuneNumberIS PushbackIS BufferedOS DataOS PrintStream : APPROFONDIMENTI 27 La gerarchia delle classi in java.io (2/2) Object Reader Writer InputStreamR CharArrayR FilterR PipedR BufferedR StringR OutputStreamW CharArrayW FilterW PipedW BufferedW StringW PrintW FileR PushbackIS LuneNumberIS FileW : APPROFONDIMENTI 28

15 Il package java.io Le classi principali sono: InputStream è una classe astratta che definisce le modalità principali di lettura di dati da una stream. Reader è la classe astratta equivalente per la lettura di caratteri. OutputStream è una classe astratta che definisce le modalità principali di scrittura di dati in una stream. Writer è la classe astratta equivalente per la scrittura di caratteri. File definisce il concetto di file in modo indipendente dalla piattaforma. Dato il nome di un file o di un direttorio, permette di trovare informazioni descrittive, quali il tipo, lo stato ed altre proprietà. RandomAccessFile è la classe che implementa le interfacce DataInput e DataOutput, dedicate all accesso casuale a file. Fornisce il metodo seek(). StreamTokenizer legge una stream e produce una sequenza di token. È possibile definire parser lessicali ridefinendo i metodi di questa classe. : APPROFONDIMENTI 29 Metodi della classe astratta InputStream read(): legge bytes dalla stream. Il metodo read() si blocca in attesa che tutta l informazione richiesta sia disponibile. In questo caso è opportuno definire un thread apposito per gestire la lettura di dati dalla stream. InputStream s = cercaunastream(); byte[] buffer = new byte[1024]; byte b; if (s.read(buffer)!= buffer.length) // legge l intero buffer System.out.println("Troppo pochi dati in ingresso"); s.read(buffer,100,300); // legge 300 byte e scrive in buffer dal byte 100 b = (byte)s.read(); // legge un byte (ma read() ritorna un int) il metodo read() restituisce il numero di byte effettivamente letti quando si raggiunge la fine della stream, restituisce -1 µ nella classe astratta Reader il metodo read() permette di leggere char da una stream : APPROFONDIMENTI 30

16 Metodi della classe astratta InputStream skip(): permette di ignorare un blocco di dati. if (s.skip(1024)!= 1024) // salta 1024 bytes System.out.println("Ci sono meno di 1024 byte da saltare"); il metodo skip() accetta come parametro un long per indicare il numero di byte da ignorare (ma nell implementazione del metodo è eseguito un cast a int!) µ nella classe astratta Reader il metodo skip() permette di saltare char da una stream (e la sua implementazione correttamente salta un numero long di caratteri) available(): restituisce il numero di bytes presenti nella stream (cioè il numero di byte che può essere letto senza bloccarsi). È possibile che alcune sottoclassi concrete non siano in grado di rispondere; in questo caso è restituito il valore 0. ready(): restituisce true se ci sono dati da leggere. Se la sottoclasse non è in grado di rispondere, restituisce false. : APPROFONDIMENTI 31 Metodi della classe astratta InputStream close(): permette di chiudere una stream. Si utilizza il costrutto finally per garantire che l istruzione close sia sempre eseguita. if (s!= null) { // verifica che la stream esista try {... // uso della stream s finally { s.close() mark() e reset(): permettono di memorizzare una posizione nella stream e successivamente di ritornare a quella posizione. if (s.marksupported() { // e supportato il marking?... //lettura della stream s.mark(1024);... // lettura di meno di 1024 byte (se supero, reset() non funziona) s.reset(); // riposiziona al mark µ a differenza di InputReader, nella classe astratta Reader il metodo mark() genera una IOException : APPROFONDIMENTI 32

17 Tipi di input stream ByteArrayInputStream crea una stream a partire da un array di byte. ByteArrayInputStream s = new ByteArrayInputStream(buffer); //crea stream di 1024 byte ByteArrayInputStream s = new ByteArrayInputStream(buffer,100,300); // crea stream di 300 byte a partire dal byte 100 di buffer µ la classe Reader corrispondente è CharArrayReader FileInputStream collega una stream ad un file. Implementa sia available() e ready(), sia skip(). FileInputStream s = new FileInputStream("/miodir/miofile"); FileInputStream s = new FileInputStream(FileDescriptor.in); /* apre stdin */ FileInputStream s = new FileInputStream(new File("/miodir/miofile")); FileDescriptor myfd = s.getfd(); // restituisce il file descriptor del file µ la classe Reader corrispondente è FileReader (che non dispone del metodo getfd()) : APPROFONDIMENTI 33 Tipi di input stream FilterInputStream è una classe astratta che permette di definire classi filtro, che eseguono operazioni di elaborazione dei dati letti. È possibile annidare un numero arbitrario di filtri. InputStream s = cercaunastream(); FilterInputStream s1 = new FilterInputStream(s); FilterInputStream s2 = new FilterInputStream(s1); FilterInputStream s3 = new FilterInputStream(s2); s3.read() // la richiesta passa attraverso s2 e s1 prima di leggere da s oppure s3 = new FilterInputStream (new FilterInputStream(new FilterInputStream(s))); µ la classe Reader corrispondente è FilterReader, che è una classe astratta, di cui non si possono creare istanze : APPROFONDIMENTI 34

18 Tipi di filtro BufferedInputStream utilizza un array di byte come cache per letture successive. In questo modo, si disaccoppia la dimensione dei blocchi di dati letti dalla stream (grandi e di dimensione regolare) da quelli (più piccoli e di dimesione irregolare) elaborati dal programma. Può essere utilizzata come filtro per altre stream. InputStream s = new BufferedInputStream (new FileInputStream("pippo")); µ la classe Reader corrispondente è BufferedReader, che dispone inoltre del metodo readline() per leggere una linea di testo (terminata con \r, \n o \r\n) LineNumberInputStream permette di tener traccia dei numeri delle linee durante la lettura della stream. LineNumberInputStream alnis; alnis = new LineNumberInputStream (new FileInputStream("pippo")); DataInputStream s = new DataInputStream (alnis); String line; while ((line = s.readline())!= null) {... /elabora la riga System.out.println("Elaborata la riga numero " + alnis.getlinenumber()); µ la classe Reader corrispondente è LineNumberReader : APPROFONDIMENTI 35 Tipi di filtro PushbackInputStream è utilizzata nei parser per rimettere un solo carattere nella stream di input dopo averlo letto per decidere la prossima operazione da eseguire. Aggiunge il nuovo metodo unread(), che rimette nella stream il byte ricevuto come parametro. nextbyte = (byte)s.read(); if (condizione particolare) s.unread(nextbyte); nextbyte = (byte)s.read(); // se condizione particolare e true, rilegge lo stesso byte In Java 1.1 sono stati introdotti nuovi metodi per rimettere nella stream di input un intero buffer o una sua parte (in modo duale ai corrispondenti metodi read()). µ la classe Reader corrispondente è PushbackReader : APPROFONDIMENTI 36

19 Tipi di filtro DataInputStream implementa l interfaccia DataInput, che specifica un insieme di metodi per leggere dati dei tipi primitivi di Java. Tutti i metodi generano IOException. void readfully(byte[] buffer); // equivalente a read() void readfully(byte[] buffer, int offset, int length); int SkipBytes(int n); // equivalente a skip() boolean readboolean(); byte readbyte(); int readint(); String readline();... Quando è raggiunta la fine della stream, questi metodi (a parte readline() e readutf()) generano una EOFException. DataInputStream s = new DataInputStream(cercaUnaStream()); try { while(true) { byte b = (byte) s.readbyte();... // elaborazione del byte catch (EOFException e) {... // raggiunta la fine della stream : APPROFONDIMENTI 37 Tipi di input stream PipedInputStream, insieme a PipedOutputStream, permette di costruire un canale di comunicazione bidirezionale tra thread. µ le classi Reader/Writer corrispondenti sono PipedReader e PipedWriter SequenceInputStream permette di creare una stream come sequenza di due (o più) stream. InputStream s1 = new FileInputStream("primaParte"); InputStream s2 = new FileInputStream("secondaParte"); InputStream s = new SequenceInputStream(s1,s2);... s.read()... // legge dalla concatenazione delle stream StringBufferInputStream è come ByteArrayInputStream, ma è basata su un array di caratteri (String) anziché di byte. µ la classe Reader corrispondente è StringReader : APPROFONDIMENTI 38

20 Tipi di input stream ObjectInputStream permette di leggere da una stream un oggetto. Implementa i metodi dell interfaccia ObjectInput (che a sua volta è un estensione di DataInput). Fornisce il nuovo metodo readobject() che ritorna un oggetto della classe Object epuò generare le eccezioni ClassNotFoundException e IOException. FileInputStream s = new FileInputStream("mioFile"); ObjectInputStream ois = new ObjectInputStream(s); int i = ois.readint(); // metodo di DataInput String frase = (String)ois.readObject(); Date data = (Date) ois.readobject(); s.close(); La serializzazione permette di trasformare un oggetto in una stream e, in seguito, ritrasformarlo in un oggetto. : APPROFONDIMENTI 39 Metodi della classe astratta OutputStream write(): scrive byte sulla stream. Si blocca fino a quando tutti i dati non sono stati scritti sulla stream. OutputStream s = cercaunastream(); byte[] buffer = new byte[1024]; byte b; s.write(buffer); s.write(buffer,100,300); // scrive 300 byte a partire dal byte 100 s.write(b); // scrive un byte µ nella classe astratta Writer il metodo write() permette di scrivere char in una stream. Sono inoltre disponibili due metodi aggiuntivi per scrivere una stringa (write(string)) e una parte di stringa. flush() permette di forzare lo svuotamento di un eventuale cache in scrittura. È implementato in modo appropriato da ciascuna sottoclasse di OutputStream. µ il metodo è presente anche nella classe astratta Writer close() chiude la stream. µ il metodo è presente anche nella classe astratta Writer : APPROFONDIMENTI 40

21 Tipi di output stream BytearrayOutputStream dirige una stream di output in un array di byte. La dimensione dell array interno cresce in modo da contenere una stream di lunghezza arbitraria. OutputStream s = new ByteArrayOutputStream(); OutputStream s1 = new ByteArrayOutputStream(1024*1024); // stream di 1Mbyte s.writeto(s1) // scrive s su s1 int dimarray = s.size(): s.reset(); // s.size() ora ritornerebbe 0 µ la classe Writer corrispondente è CharArrayWriter FileOutputStream collega una stream di output ad un file. Dispone di metodi analoghi a FileInputStream. FileOutputStream s = new FileOutputStream("/miodir/miofile"); FileDescriptor afd = s.getfd(); /* restituisce il file descriptor del file */ FileOutputStream out = new FileOutputStream(FileDescriptor.out); /* scrive su stdout */ FileOutputStream err = new FileOutputStream(FileDescriptor.err); /* scrive su stderr */ µ la classe Writer corrispondente è FileWriter FilterOutputStream è analoga a FilterInputStream; permette di definire classi filtro, che eseguono operazioni di elaborazione dei dati scritti. µ la classe Writer corrispondente è FilterWriter : APPROFONDIMENTI 41 Filtri di output BufferedOutputStream è analoga a BufferedInputStream; utilizza un array come cache in scrittura. Implementa il metodo flush(). OutputStream s = new BufferedOutputStream(new FileInputStream("miofile")); µ la classe Writer corrispondente è BufferedWriter, che dispone inoltre del metodo newline() che invia in output uno o più caratteri per la nuova linea adatti al sistema operativo corrente DataOutputStream implementa l interfaccia DataOutput, che specifica un insieme di metodi per scrivere i dati come tipi primitivi di Java. Tutti i metodi generano IOException. L elaborazione di un file può essere eseguita in questo modo: DataInput adi = new DataInputStream(new FileInputStream("source")); DataOutput ado = new DataOutputStream(new FileOutputStream("dest")); String line; while ((line = adi.readline())!= null) {... // elaborazione linea ado.writechars(line); adi.close(); ado.close(); : APPROFONDIMENTI 42

22 Filtri di output PrintStream è collegata a dispositivi di output. Contiene i metodi per eseguire la stampa di tutti i tipi primitivi di Java (print() e println()). Implementa flush(). System.out.println(...); // out contiene un istanza di PrintStream Esempio: programma che realizza il comand cat di Unix (legge lo standard input una linea per volta e lo scrive sullo standard output). public class Cat { public static void main(string argv[]) { DataInput d = new DataInputStream(System.in); String line; try ( while((line = d.readline())!= null) System.out.println(line); catch (IOException ignored) { : APPROFONDIMENTI 43 Tipi di output stream ObjectOutputStream permette di scrivere un oggetto in una stream. Implementa i metodi dell interfaccia ObjectOutput (che a sua volta è un estensione di DataOutput). Fornisce il nuovo metodo writeobject(object o) che scrive l oggetto o in una stream e può generare l eccezione IOException. FileOutputStream s = new FileOutputStream("mioFile"); ObjectOutputStream oos = new ObjectOutputStream(s); oos.writeint(12345); // metodo di DataOutput oos.writeobject("frase"); oos.writeobject(new Date()); oos.flush(); s.close(); : APPROFONDIMENTI 44

23 import java.awt.*; import java.io.*; import java.awt.event.*; Esempio: visualizzazione di un file (1/2) public class FileViewer extends Frame { Button close; // Query the size of the specified file, create an array of bytes big // enough, and read it in. Then create a TextArea to display the text // and a "Close" button to pop the window down. public FileViewer(String filename) throws IOException { super("fileviewer: " + filename); File f = new File(filename); int size = (int) f.length(); int bytes_read = 0; FileInputStream in = new FileInputStream(f); byte[] data = new byte[size]; while(bytes_read < size) bytes_read += in.read(data, bytes_read, size-bytes_read); TextArea textarea = new TextArea(new String(data), 24, 80); textarea.setfont(new Font("Helvetica", Font.PLAIN, 12)); textarea.seteditable(false); this.add("center", textarea); : APPROFONDIMENTI 45 Esempio: visualizzazione di un file (2/2) close = new Button("Close"); close.addactionlistener(new ActionListener() { public void actionperformed(actionevent event) { System.exit(0); ); this.add("south", close); this.pack(); this.show(); // The FileViewer can be used by other classes, or it can be // used standalone with this main() method. static public void main(string[] args) throws IOException { if (args.length!= 1) { System.out.println("Usage: java FileViewer <filename>"); System.exit(0); try { Frame f = new FileViewer(args[0]); catch (IOException e) { System.out.println(e); : APPROFONDIMENTI 46

24 L applicazione FileViewer : APPROFONDIMENTI 47 Esempio: il filtro grep (1/2) import java.io.*; // This class is a FilterReader that filters out all lines that // do not contain the specified substring. public class GrepReader extends FilterReader { String substring; BufferedReader in; public GrepReader(BufferedReader in, String substring) { super(in); this.in = in; this.substring = substring; // This is the filter: read lines from the DataInputStream, // but only return the lines that contain the substring. // When the DataInputStream returns null, we return null. public final String readline() throws IOException { String line; do { line = in.readline(); while ((line!= null) && line.indexof(substring) == -1); return line; : APPROFONDIMENTI 48

25 Esempio: il filtro grep (2/2) import java.io.*; // This class prints the lines of a file that contain a specified substring. public class Grep { public static void main(string args[]) { if ((args.length == 0) (args.length > 2)) { System.out.println("Usage: java Grep <substring> [<filename>]"); System.exit(0); try { BufferedReader d; if (args.length == 2) d = new BufferedReader(new InputStreamReader(new FileInputStream(args[1]))); else d = new BufferedReader(new InputStreamReader(System.in)); GrepReader g = new GrepReader(d, args[0]); String line; for(;;) { line = g.readline(); if (line == null) break; System.out.println(line); g.close(); catch (IOException e) { System.err.println(e); : APPROFONDIMENTI 49 Multithreading Un thread è un sottoprocesso all interno di un programma µ multithreading quando più thread eseguono all interno dello stesso programma Più thread possono eseguire in parallelo la stessa porzione di codice µ è necessario poter definire operazioni atomiche, cioè insiemi di istruzioni che gli altri thread vedono come se eseguissero in una volta sola Se più thread eseguissero contemporaneamente il codice public class ThreadCounter { int crucialvalue; public void countme() { crucialvalue +=1; public int howmany() { return crucialvalue; poiché l operazione += richiede più di un passo, il valore di crucialvalue potrebbe risultare sbagliato. : APPROFONDIMENTI 50

26 Multithreading Il modificatore synchronized nella definizione di un metodo permette di indicare che il codice eseguito dal metodo deve essere atomico (thread-safe) il metodo può essere eseguito da un thread per volta è bloccato l oggetto su cui il metodo è invocato µ non è opportuno definire synchronized metodi complessi che eseguono operazioni lunghe Il codice corretto sarebbe in questo caso: public class ThreadCounter { int crucialvalue; public synchronized void countme() { crucialvalue +=1; public int howmany() { return crucialvalue; Il modificatore volatile permette di specificare che una variabile può essere aggiornata in modo asincrono da più processi, quindi deve essere mantenuta in memoria e non all interno di registri. : APPROFONDIMENTI 51 Multithreading Esempio di lettura di più variabili correlate: public class Point { private float x, y; public float x() { return x; public float y() { return y; public class UnsafePointPrinter { public void print(point p) { System.out.println("The point s x is " p.x() + " and y is " p.y() ); I metodi x() e y() non richiedono sincronizzazioni poiché restituiscono il valore di una variabile. Il metodo UnsafePointPrinter invece deve garantire che le due istanze x e y non siano modificate da altri thread durante l esecuzione dell istruzione println. : APPROFONDIMENTI 52

27 Multithreading L istruzione synchronized permette di specificare che l esecuzione di un blocco di codice deve avvenire in modo atomico, bloccando l accesso ad altri thread presenti nel sistema. µ È opportuno, per motivi di efficienza, limitare al massimo il codice che deve essere bloccato da un thread. public class TryAgainPointPrinter { public void print(point p) { float safex, safey; synchronized(this) { safex = p.x(); // queste due linee sono eseguite safey = p.y(); // in modo atomico System.out.println("The point s x is " safex + " and y is " safey ); Nell esempio, l istruzione synchronized blocca l istanza della classe TryAgainPointPrinter µ l esempio non è corretto poiché non è bloccato l oggetto p. : APPROFONDIMENTI 53 Il metodo print() corretto: public class SafePointPrinter { public void print(point p) { float safex, safey; Multithreading synchronized(p) { // nessuno puo modificare p safex = p.x(); // mentre queste due linee sono eseguite safey = p.y(); // in modo atomico System.out.println("The point s x is " safex + " and y is " safey ); Per rendere sicura la classe Point, è necessario definire un unico metodo sicuro per l aggiornamento delle variabili: public class Point { private float x, y; public float x() { return x; public float y() { return y; : APPROFONDIMENTI 54 public synchronized void setxandy (float newx, float newy) { x = newx; y = newy;

28 Multithreading L uso del modificatore synchronized permette anche di garantire che possa essere eseguito solo un metodo alla volta (bloccando l oggetto su cui è invocato). public class ReallySafePoint { private float x, y; public synchronized void setxandy (float newx, float newy) { x = newx; y = newy; public synchronized Point getuniquepoint() { return new Point(x,y); // non devo piu sincronizzare quando // faccio get, perche restituisce un oggetto public synchronized void scale (float scalex, float scaley) { x *= scalex; y *= scaley; public synchronized void add (ReallySafePoint arsp) { Point p = arsp.getuniquepoint(); // uso il metodo protetto per leggere x += p.x(); // nessuno conosce l esistenza di p y += p.y(); // quindi non e necessario proteggerlo // alla fine p e scartato da garbage collection : APPROFONDIMENTI 55 Protezione delle variabili di classe Il modificatore synchronized blocca l oggetto su cui il metodo è invocato public class StaticCounter { private static int crucialvalue; public synchronized void countme() { crucialvalue +=1; // blocco l istanza µ Il modificatore synchronized blocca solo l istanza su cui è invocato il metodo countme(), ma non la variabile di classe (la variabile di classe potrebbe essere modificata utilizzando istanze diverse della stessa classe). Per bloccare una variabile di classe, è necessario bloccare la classe a cui appartiene public class StaticCounter { private static int crucialvalue; public void countme() { synchronized(getclass()); { crucialvalue +=1; // blocco la classe : APPROFONDIMENTI 56

29 Creazione di thread Per definire un nuovo tipo di thread si crea una sottoclasse della classe Threads: public class IlMioPrimoThread extends Thread { public void run() {... // operazioni eseguite dal thread Per creare un thread: IlMioPrimoThread ampt.start(); ampt.stop(); ampt.suspend(); ampt.resume(); ampt = new IlMioPrimoThread(); // chiamo il metodo run() attivando il thread // blocco il thread // sospendo il thread // faccio ripartire il thread Un thread è automaticamente sospeso e successivamente riattivato quando raggiunge un punto di sincronizzazione (delimitato da synchronized). : APPROFONDIMENTI 57 Creazione di thread Se la classe appartiene già ad una gerarchia, è possibile utilizzare l interfaccia Runnable(), che contiene solo il metodo run(). public class IlMioSecondoThread extends ClasseImportante implements Runnable { public void run() { Si usa un istanza di IlMioSecondoThread IlMioSecondoThread amst = new IlMioSecondoThread(); 2. Si crea un thread, specificando amst come l obiettivo del thread Thread athread = new Thread(aMST); 3. l invocazione di start() su athread causa l invocazione del metodo run() di amst athread.start(); Versione abbreviata: new Thread (new IlMioSecondoThread()).start(); : APPROFONDIMENTI 58

30 Schedulazione dei thread Lo scheduler è la parte del sistema che decide l ordinamento real-time dei thread. Le modalità fondamentali di schedulazione sono: non-preemptive: lo scheduler fa eseguire il thread corrente per sempre e attende che il thread comunichi esplicitamente quando è possibile far partire un altro thread µ utilizzato in applicazioni real-time particolarmente critiche, in cui essere interrotti troppo a lungo oppure nel momento sbagliato può causare danni rilevanti preemptive time-slicing: lo scheduler esegue il thread corrente fino a quando ha consumato il tempo a sua disposizione, poi lo interrompe, lo sospende e fa ripartire un altro thread per l intervallo di tempo successivo µ più semplice scrivere programmi, perchè l allocazione delle risorse è decisa completamente dallo scheduler (i programmi non devono eseguire yield() per cedere il controllo) È possibile definire un ordinamento totale tra i thread assegnando loro una priorità. I thread a priorità maggiore: eseguono più frequentemente, oppure ricevono un intervallo di esecuzione più lungo interrompono l esecuzione di thread a priorità inferiore anche prima che sia terminato l intervallo di tempo loro assegnato : APPROFONDIMENTI 59 Controllare il tipo di scheduler Lo scheduler di Java permette di assegnare priorità ai thread, ma non è definita la modalità con cui avviene la schedulazione di thread con la stessa priorità. µ dipende dalla piattaforma A parità di priorità, per controllare se lo scheduler Java si comporta come uno scheduler preemptive o non preemtive si può utilizzare il seguente codice: public class RunnablePotato implements Runnable { public void run() { while (true) System.out.println(Thread.currentThread().getName()); public class PotatoThreadTester { public static void main(string argv[]) { RunnablePotato arp = new RunnablePotato(); new Thread(aRP, "una patata").start(); new Thread(aRP, "due patate").start(); : APPROFONDIMENTI 60

31 Risultato Schedulazione non-preemptive Controllare il tipo di scheduler Schedulazione preemptive una patata una patata una patata una patata una patata... una patata una patata... due patate due patate... due patate Per garantire che il comportamento sia preemptive con divisione di tempo: public class RunnablePotato implements Runnable { public void run() { while (true) { System.out.println(Thread.currentThread().getName()); Thread.yield(); // cedo il controllo ad un altro thread // abbreviazione di Thread.currentThread().yield() : APPROFONDIMENTI 61 Gestione delle priorità I valori che rappresentano la priorità minima, normale e massima assegnabile a un thread sono variabili di classe della classe Thread: Thread.MIN PRIORITY, Thread.NORM PRIORITY, Thread.MAX PRIORITY (le priorità sono correntemente definite in un intervallo da 1a10convalore normale 5). Per controllare la gestione delle priorità eseguita dallo scheduler: public class PriorityTest { public static void main(string argv[]) { Runnable Potato arp = new RunnablePotato(); Thread t1 = new Thread(aRP, " one potato"); Thread t2 = new Thread(aRP, " two potato"); t2.setpriority(t1.getpriority() + 1); t1.start(); t2.start(); // alla priorita Thread.NORM_PRIORITY+1 µ Se la prima riga è una patata, lo scheduler non interrompe considerando le priorità. : APPROFONDIMENTI 62

32 Informazioni sui thread: la applet ThreadLister (1/3) import java.io.*; public class ThreadLister { // Display info about a thread. private static void print_thread_info(printstream out, Thread t, String indent) { if (t == null) return; out.println(indent + "Thread: " + t.getname() + " Priority: " + t.getpriority() + (t.isdaemon()?" Daemon":"") + (t.isalive()?"":" Not Alive")); // Display info about a thread group and its threads and groups private static void list_group(printstream out, ThreadGroup g, String indent) { if (g == null) return; int num_threads = g.activecount(); int num_groups = g.activegroupcount(); Thread[] threads = new Thread[num_threads]; ThreadGroup[] groups = new ThreadGroup[num_groups]; g.enumerate(threads, false); g.enumerate(groups, false); out.println(indent + "Thread Group: " + g.getname() + " Max Priority: " + g.getmaxpriority() + (g.isdaemon()?" Daemon":"")); for(int i = 0; i < num_threads; i++) print_thread_info(out, threads[i], indent + " "); : APPROFONDIMENTI 63 Informazioni sui thread: la applet ThreadLister (2/3) for(int i = 0; i < num_groups; i++) list_group(out, groups[i], indent + " "); // Find the root thread group and list it recursively public static void listallthreads(printstream out) { ThreadGroup current_thread_group; ThreadGroup root_thread_group; ThreadGroup parent; // Get the current thread group current_thread_group = Thread.currentThread().getThreadGroup(); // Now go find the root thread group root_thread_group = current_thread_group; // Se la RuntimePermission modifythreadgroup non e garantita in.java.policy // (tramite policytool), l applet non riesce a visitare i threadgroup parenti try { parent = root_thread_group.getparent(); catch (SecurityException e) { parent = null; while(parent!= null) { root_thread_group = parent; parent = parent.getparent(); // And list it, recursively list_group(out, root_thread_group, ""); : APPROFONDIMENTI 64

33 Informazioni sui thread: la applet ThreadLister (3/3) import java.applet.*; import java.awt.*; import java.io.*; public class AppletThreadLister extends Applet { TextArea textarea; // Create a text area to put our listing in public void init() { textarea = new TextArea(20, 60); this.add(textarea); Dimension prefsize = textarea.getpreferredsize(); this.resize(prefsize.width, prefsize.height); // Do the listing. Note the cool use of ByteArrayOutputStream. public void start() { ByteArrayOutputStream os = new ByteArrayOutputStream(); PrintStream ps = new PrintStream(os); ThreadLister.listAllThreads(ps); textarea.settext(os.tostring()); : APPROFONDIMENTI 65 La applet ThreadLister : APPROFONDIMENTI 66

34