JAVA Caratteristiche e costrutti fondamentali

Transcript

1 JAVA Caratteristiche e costrutti fondamentali Andrea BEI (andrea.bei@libero.it)

2 CARATTERISTICHE DI JAVA Object Oriented Distribuito e Portabile Robusto Concorrente (multithreading) Livelli di astrazione

3 Object Oriented Sintassi simile a C e C++ Elimina i costrutti più "pericolosi" di C e C++ aritmetica dei puntatori preprocessore (#define) (de)allocazione esplicita della memoria Funzionalità di garbage collection (GC) automatica

4 Distribuito e Portabile Incorpora molte funzionalità per l accesso alla rete (TCP/IP) Il compilatore produce codice di tipo bytecode interpretato da una virtual-machine e indipendente dall architettura HW Lo stesso codice gira su piattaforme Unix, Microsoft e Macintosh

5 Robusto Rilevamento errori e Type-checking a tempo di compilazione e di esecuzione Mascheramento dei puntatori all'utente Controllo automatico degli indici degli array Gestione delle eccezioni da parte dell'utente Gestione della memoria (allocazione & GC)

6 Livelli di astrazione Interfacce Classi astratte Classi e programmi Codice Sorgente file.java Compilazione Codice Byte-Code file.class Esecuzione JAVA VIRTUAL MACHINE Windows Unix Macintosh

7 CLASSI [Doc comment][modifiers] class ClassName [extends SuperClassName] [implements InterfaceName [, InterfaceName]] {ClassBody} Doc comment - commento "di documentazione" Modifiers - uno dei cinque qualificatori abstract, final, public, private, synchronizable extends - la classe è sottoclasse di un'altra (e di una sola: ereditarietà singola) implements - la classe realizza una o più interfacce (può "simulare" ereditarietà multipla) ClassBody - gli attributi e i metodi della classe

8 TIPI DI CLASSE Quattro tipi di classe abstract: tra i vari metodi, deve contenerne almeno uno astratto, ma non può contenere metodi privati o statici; deve dare origine a sottoclassi; non può essere istanziata final: termina una catena di classi-sottoclassi, non può dare origine a ulteriori sottoclassi public: può essere usata da altre classi nel package che ne contiene la dichiarazione senza formalità; disponibile anche in altri package, purché vi venga "importata" synchronizable: tutti i metodi interni sono "sincronizzati"

9 COMMENTI Il codice sorgente JAVA può essere commentato con tre diversi stili // Doppio slash va bene per commenti di una riga /* Commenti con un numero di righe maggiore o uguale a uno vanno delimitati in questo modo */ /** Commenti delimitati così vengono inclusi nella documentazione generabile automaticamente a partire dal codice sorgente e vanno inseriti prima di una dichiarazione di classe o di interfaccia */

10 TIPI SEMPLICI I tipi semplici predefiniti sono: boolean - tipo enumerativo (due elementi) char - carattere di 16 bit (Unicode) byte - intero di 8 bit con segno short - intero di 16 bit con segno int - intero di 32 bit con segno long - intero di 64 bit con segno float - floating-point di 32 bit double - floating-point di 64 bit L accesso ai dati semplici è diretto

11 TIPI COMPOSTI Tipi composti predefiniti: Array Classi Interfacce L accesso ai dati composti avviene tramite puntatori non accessibili dall utente

12 TIPO COMPOSTO ARRAY Array di dati semplici o composti: char a[]; int a[]; (semplici) String tema[]; Point poligono[]; int matrice[][]; (composti) Indicizzati con int (indice del primo elemento = 0), Dichiarazione, creazione e inizializzazione possono essere fatte in fasi distinte o contemporaneamente. Es: char ca[]; // dichiarazione ca = new char[4]; // creazione ca[0]= N ;ca[1]= S ;ca[2]= E ;ca[3]= O // inizializzazione char ca[]=new char[4]; // dichiaraz. E creazione ca[0]= N ;ca[1]= S ;ca[2]= E ;ca[3]= O // inizializzazione char ca[]={ N, S, E, O } // dich.,creaz. E inizializzaz.

13 CLASSI, ATTRIBUTI E METODI Una classe è l astrazione di una entità reale di cui descrive lo stato con gli attributi e il comportamento con i metodi Esempio di classe: la classe Serbatoio public class Serbatoio { int livello; /* attributo */ public Serbatoio () { /* metodo costruttore: ha lo livello = 10; stesso nome della classe */ } public void Rifornimento (int j) { /* metodo */ livello = livello+j; } public void Consumo (int j) { /* metodo */ livello = livello-j; } }

14 ATTRIBUTO this E implicitamente presente in ogni oggetto e punta all oggetto stesso Es: public class Serbatoio { int livello; /* attributo */ public Serbatoio (int livello) { /* parametro */ this.livello = livello; /* disambiguazione */ }... } Permette di usare lo stesso nome per attributi e parametri

15 CREAZIONE, USO E RIFERIMENTO DI OGGETTI Creazione e uso di un oggetto della classe Serbatoio Serbatoio S; /* dichiarazione,*/ S = new Serbatoio(); /* creazione: l attributo livello vale 10 */ S.consumo(5); /* ora livello vale 5 */ S.rifornimento(10); /* livello vale 15 */ Riferimenti ad un oggetto della classe Serbatoio Serbatoio S, S1; /* dichiarazione, non creazione */ S = new Serbatoio(); /* S punta ad un oggetto Serbatoio */ S1=S; /* S1 e S puntano allo stesso oggetto */ S1=null; S=null; /* l oggetto non è più accessibile */

16 DISTRUZIONE DI OGGETTI Java non supporta "distruttori" espliciti: gli oggetti privi di puntatori incidenti (non più accessibili) vengono eliminati automaticamente e la memoria che questi occupano viene liberata String s; /* dichiarazione */ s = new String ("abc"); /* creazione: s punta a "abc" */ s = "def"; /* "abc" non è più puntata da s */ Questo viene fatto da un thread (garbage collector, o GC) che viene eseguito contemporaneamente ai thread utente e di sistema Vantaggi: il programmatore non si deve preoccupare della deallocazione della memoria

17 FINALIZZATORI DI OGGETTI Per un oggetto potrebbero essere previste delle operazioni da effettuare prima della definitiva eliminazione (per esempio la chiusura di file aperti) Prima di procedere alla eliminazione di un oggetto il GC invoca il suo metodo finalize, definibile dall utente protected void finalize () { close (); } /*chiudi tutti i file aperti */ Il metodo finalize esiste sempre: se non è stato ridefinito viene ereditato da Object la classe più generale nella gerarchia delle classi JAVA

18 EREDITARIETA E' il meccanismo di specializzazione che consente di derivare una sottoclasse da una classe data Esempio: Fuoristrada come sottoclasse di Automobile public class Automobile {int Ruote, Marce, Livello; public Automobile () { Ruote = 4; Marce = 5; Livello=10} public void Rifornimento(int Rif) { Livello=Livello+ Rif } public void Consumo(int Cons) { Livello=Livello-Cons; } } public class Fuoristrada extends Automobile { int Serbatoio_di_riserva; public Fuoristrada (int SR) { Serbatoio_di_riserva = SR; } public void Rifornimento(int Rif) /* ridefinizione */ { Livello=Livello+Rif/2; Serbatoio_di_riserva=Serbatoio_di_riserva+Rif/2 } }

19 INCAPSULAMENTO Quattro tipi di diritti d'accesso a metodi e attributi - public void TuttiAccedono () {... } - protected void SoloSottoClassiAccedono () {... } - private void NessunoAccede () {... } - void SoloDaDentroIlPackage () {... } L'ultimo tipo si chiama "friendly Attributi statici: condivisi da tutti gli oggetti della stessa classe; Metodi statici: operano solo su dati statici class NewDocument extends Document { static int Version = 10; int Chapters; static void NewVersion () { Version++; } /* OK */ static void AddChapter () { Chapters++; } } /* KO */

20 CLASSI ASTRATTE Create per generalizzazione, rappresentano descrizioni "incomplete" di oggetti Non posseggono esemplari ("non possono essere istanziate"), ma è possibile derivarne sottoclassi. Usate principalmente come strumenti di polimorfismo per definire operazioni ("print") comuni a più classi poco correlate public abstract class Graphics { /* generica */ public abstract void DrawLine(int x1,y1,x2,y2); } public class VGA extends Graphics { /*specifica */ public void DrawLine(int x1,y1,x2,y2) { <codice per VGA> }}

21 INTERFACCE Alternativa alle classi astratte: non richiede la derivazione esplicita di sottoclassi public interface AudioClip { void play (); /* avvia i esecuzione */ void loop (); /* esegui ciclicamente una audio clip */ void stop (); } /* interrompi l esecuzione */ class MyAudio implements AudioClip { void play () { <codice che implementa play> } void loop () { <codice che implementa loop> } void stop () { <codice che implementa stop> } } class YourAudio implements AudioClip { <codice> } I metodi possono essere public o abstract, gli attributi public, static o final

22 POLIMORFISMO Possibile utilizzo di metodi omonimi. Devono essere distinguibili per il numero e/o per il tipo degli argomenti (arità) Esempio: Serbatoio polimorfo public class Serbatoio { int livello; /* attributo */ public Serbatoio () { /* metodo costruttore: ha lo i = 10; stesso nome della classe */ } public Serbatoio (int j) { /* altro metodo costruttore livello= j; diverso dal precedente */ }... }

23 JAVA Packages e Classi fondamentali Andrea BEI (andrea.bei@libero.it)

24 PACKAGE: Definizione e Uso Contenitori di classi organizzati in modo gerarchico java lang sql io String System La classe String è definita nel package java.lang il file String.class si trova nella directory CLASSPATH\java\lang\ Prima di usare una classe occorre importarla dal package in cui è definita con il comando: import package1[.package2] [packagen].(classname *) es: import java.lang.string; oppure import java.lang.*;

25 PACKAGE: Creazione e Popolamento 4 operazioni fondamentali Creazione della directory che ospiterà il package es: C:\MyPackages\P1\ Concatenazione della root con la variabile di ambiente CLASSPATH es: SET CLASSPATH=c:\jdk1.1\lib\classes.zip;c:\MyPackages; Creazione del file sorgente con la definizione della classe preceduta dall istruzione: package pkg1[.pkg2] [.pkgn] es: (file Point.java) package P1; public class Point { int x; int y; } Compilazione del file sorgente e copia del file.class nella directory definitiva: es: c:\copy Point.class c:\mypackages\p1

26 Package e classi predefinite Gestione delle stringhe (java.lang) String StringBuffer Scrittura e lettura (java.io) Input e Output Stream Object Serialization Random Access File Accesso alle risorse e proprietà del sistema (java.lang) System Accesso alla rete (java.net) InetAddress Socket ServerSocket

27 String Definizione: Un oggetto di tipo String è una stringa costante (più economico di StringBuffer) Creazione: Esplicita: tramite il costruttore polimorfo String() es: String S=new String( parola ); String S=new String(); Implicita: quando il compilatore incontra una serie di caratteri delimitati da virgolette crea un oggetto di tipo String a cui assegna la stringa individuata. es: String S= parola ; è uguale a String S=new String( parola ); Metodi principali: lenght(): ritorna la lunghezza della stringa (es: S.lenght()=6) charat(int i): ritorna il carattere in posizione i-esima (es: S.charAt(3)= r ) indexof(int char): ritorna l indice della 1 occorrenza di char (es: S.indexOf( o )=4) lastindexof(int char): come sopra ma per l ultima occorrenza di char substring(int da; int a): ritorna una sottostringa (es:s.substring(2,4)= ro ) Operatore di concatenazione: + es: String S= prova + di + concatenazione ;

28 StringBuffer Definizione: Un oggetto di tipo StringBuffer è una stringa variabile nel contenuto e nella dimensione Creazione: tramite i costruttori StringBuffer() StringBuffer(int) StringBuffer(String) es: StringBuffer S=new StringBuffer( parola ); Metodi: oltre ai metodi definiti nella classe String e all operatore di concatenazone (+) definisce i seguenti metodi polimorfi per la manipolazione di stringhe: append(char c) aggiunge in coda il carattere c (es: S.append( a ); ) insert(int offset,char c) inserisce in posizione offset+1 il carattere c setcharat(int pos,char c) sovrascrive il carattere in posizione pos con c capacity() restituisce la quantità di spazio allocato setlenght(int lenght) imposta la dimensione della stringa a lenght

29 Esempio di uso di String e StringBuffer public class ReverseString { public static String reverseit(string source) { int i, len = source.length(); StringBuffer dest = new StringBuffer(len); for (i = (len - 1); i >= 0; i--) dest.append(source.charat(i)); return dest.tostring(); } }

30 Lettura e Scrittura di dati Astrazione su sorgente e destinazione dei dati: stream di input e stream di output Algoritmi di lettura e scrittura standard Lettura Scrittura apertura dello stream di input apertura dello stream di output while ci sono dati da leggere while ci sono dati da scrivere leggi scrivi chiusura stream chiusura stream Il package java.io contiene una collezione di classi che implementa il concetto di stream e supporta gli algoritmi mostrati sopra Gli stream possono essere suddivisi per tipo di dato: stream di caratteri (16 bit), stream di byte (8 bit) funzionalità: data sink stream (durante il transito i dati non sono processati) processing stream (i dati vengono processati es: bufferizzazione)

31 Stream di caratteri Le classi astratte Reader e Writer forniscono le API e una parziale implementazione di stream di caratteri di input e output Le sottoclassi di Reader e Writer implementano stream specializzati in bianco: processing stream in grigio: data sink stream

32 Stream di caratteri: Classi Data Sink Stream fondamentali CharArrayReader, CharArrayWriter: lettura e scrittura in memoria FileReader, FileWriter: lettura e scrittura su File PipedReader, PipedWriter: Implementano le componenti input e output di una Pipe. Le pipe sono utilizzate per la comunicazione tra thread. PipedReader e PipedWriter sono collegati o tramite costruttori o tramite il metodo connect. Processing Stream fondamentali BufferedReader, BufferedWriter: lettura e scrittura bufferizzata riduce gli accessi aumenta l efficienza LineNumberReader: lettura bufferizzata tenendo traccia delle linee. Possiede il metodo ReadLine() per leggere linea per linea

33 Stream di caratteri: esempio import java.io.*; public class Copia { // questo programma copia il file input.txt sul file output.txt public static void main(string[] args) throws Exception { File inputfile = new File("input.txt"); // Tramite File si può accedere alle proprietà File outputfile = new File("output.txt"); // del file es: dimensione, protezioni, ecc. FileReader in = new FileReader(inputFile); // l oggetto in ora è uno stream di input FileWriter out = new FileWriter(outputFile); // associato al file inputfile BufferedReader inb=new BufferedReader(in); //l oggetto inb è uno stream di input BufferedWriter outb=new BufferedWriter(out); // bufferizato a partire da in } } int c; while ((c = inb.read())!= -1) outb.write(c); inb.close(); outb.close();

34 Stream di byte Le classi astratte InputStream e OutputStream forniscono le API e una parziale implementazione di stream di byte di input e output Le sottolassi di InputStream e OutputStream implementano stream di byte specializzati in bianco: processing stream in grigio: data sink stream

35 Stream di byte: Classi Funzioni analoghe alle classi che implementano stream di char tranne che per le classi ObjectOutputStream, ObjectInputStream Queste permettono di serializzare un oggetto ovvero di codificarlo come stream di bytre per poi salvarlo o trasmetterlo via rete. Es: Salvataggio su file di due oggetti FileOutputStream out = new FileOutputStream( Tempo"); ObjectOutputStream s = new ObjectOutputStream(out); s.writeobject( Oggi"); s.writeobject(new Date()); // Scrive nel file Tempo 2 oggetti: la stringa Oggi s.flush(); // ed un oggetto di tipo Date() Es: Recupero di due oggetti salvati su un file FileInputStream in = new FileInputStream( Tempo"); ObjectInputStream s = new ObjectInputStream(in); String today = (String)s.readObject(); // Gli oggetti vengono letti dal file Tempo Date date = (Date)s.readObject();

36 Random Access File La classe RandomAccessFile: Consente la lettura e la scrittura di file ad accesso casuale. Es: RandomAccessFile F=new RandomAccessFile( input.txt, r ); // lettura RandomAccessFile F=new RandomAccessFile( input.txt, rw ); // lettura e scrittura Supporta il concetto di file pointer per il mantenimento della posizione corrente nel file. Il file pointer è l offset in byte dall inizio del file Per il posizionamento del file pointer fornisce i metodi: skipbytes(int n) fa avanzare il file pointer di n byte seek(long pos) imposta il file pointer alla posizione pos getfilepointer restituisce il valore del file pointer

37 System Fornisce una interfaccia alle risorse del sistema. Implementa lo standard input, output ed error Le sue variabili e i suoi metodi sono statici ( Non può essere istanziata) e vi si puo accedere solo tramite dot-notation System.<variabile>; System.<metodo>; Variabili in Standard input. Variabile di tipo InputStream out Standard output. Variabile di tipo PrintStream err Standard err. Variabile di tipo PrintStream L istruzione: System.out.println( una frase qualsiasi ); fornisce il display della stringa una frase qualsiasi Metodi currenttimemillis() fornisce in ms il tempo di sistema dal 1 Gennaio 1970 setin, setout, seterr riassegnano rispettivamente standard input, output ed error exit(int i) exit dall interprete java con return code = i

38 Accesso alla rete: TCP e UDP I computer collegati ad Internet comunicano tramite i protocolli TCP o UDP. TCP fornisce una comunicazione affidabile (ritrasmissionedei pacchetti persi). Tutti i pacchetti spediti dall applicazione mittente vengono ricevuti dall applicazione destinataria nell ordine con cui sono stati spediti. (Telnet, HTTP ) UDP fornisce una comunicazione non affidabile. Non garantisce che una volta spediti i pacchetti giungano a destinazione. (Applicazioni real-time, audio, video ) L affidabilità di TCP si paga con una maggiore durata complessiva della comunicazione

39 Accesso alla rete: Socket Il protocollo IP definisce l indirizzamento dei computer collegati ad Internet. Ad ogni computer è univocamente associato un indirizzo IP formato da 4 byte (es: ) Ogni computer rende disponibili un certo numero di porte ( ) usate dalle applicazioni per trasmettere o ricevere dati Applicazioni diverse che girano contemporaneamente sullo stesso computer devono collegarsi ( effettuare un bind ) a porte diverse Un Socket identifica una porta su un dato computer ed è formato da Indirizzo IP del computer e numero di Porta

40 Accesso alla rete: le classi del package java.net La classe InetAddress Definizione: Un oggetto di questo tipo è un Indirizzo IP Creazione:. La classe InetAddress non possiede costruttori publici ma dei metodi factory (metodi static che ritornano un istanza dell oggetto). Es: // Ad Address viene assegnato l indirizzo della macchina locale InetAddress Address = InetAddress.getLocalHost(); // Ad Address viene assegnato l indirizzo IP del sito InetAddress=InetAddress.getByName( ); Metodi principali: gethostname: restituisce l indirizzo mnemonico (es: getaddress: restituisce l indirizzo numerico (es: )

41 Accesso alla rete: le classi del package java.net La classe Socket Definizione: Socket viene usata per la creazione di un Socket TCP da una applicazione client. Creazione: Socket(String host, int port) crea un socket connettendo la macchina locale alla macchina host e alla porta port Socket(InetAddress address, int port) Metodi principali: getinputstream() restituisce l InputStream relativo a questo Socket getoutputstream() restituisce l OutputStream relativo a questo Socket

42 Accesso alla rete: le classi del package java.net La classe ServerSocket Definizione: ServerSocket viene usata per la creazione di un Socket TCP da una applicazione Server che rimane in ascolto di richieste di connessione da parte dei Client) Creazione: ServerSocket(int port) crea un socket per il server sulla porta port ServerSocket(int port, int timeout) crea un socket per il server aspettando al massimo timeout millisecondi che la porta si liberi Metodi: accept() la chiamata a questo metodo è bloccante: l applicazione rimane in attesa di richieste di connessioni al socket. Il metodo restituisce il Socket su cui è stata accettata la connessione.

43 Esempio di comunicazione Client/Server LAN del DIS (Via Salaria) LAN del CNR (Via Labicana) Internet disparc10.dis.uniroma1.it CLIENT.CLASS SERVER.CLASS sunshine.iasi.rm.cnr.it

44 Esempio di comunicazione Client/Server: il programma client import java.lang.*; import java.net.*; import java.io.*; /* IL PROGRAMMA CLIENT INVIA OGNI LINEA DI TESTO DIGITATA DALL UTENTE AL PROGRAMMA SERVER */ class client { public static void main(string argv[]) throws Exception { InetAddress Address=InetAddress.getByName("sunshine.iasi.rm.cnr.it"); Socket s = new Socket(Address,5200); PrintWriter out = new PrintWriter(s.getOutputStream(), true); BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); String userinput; while ((userinput = stdin.readline())!= null) out.println(userinput); s.close(); stdin.close(); out.close(); } }

45 import java.lang.*; import java.net.*; import java.io.*; // IL PROGRAMMA SERVER STAMPA LE LINEE DI TESTO RICEVUTE DAL CLIENT class server { public static void main(string argv[]) throws Exception { ServerSocket acceptsocket = new ServerSocket(5200); while(true) { Socket s=acceptsocket.accept(); // attesa di una richiesta di connessione }} Esempio di comunicazione Client/Server: il programma server BufferedReader input = new BufferedReader(new InputStreamReader(s.getInputStream())); String line; while ((line = input.readline())!= null) System.out.println(line); input.close(); s.close(); }