Slide 1: CORSO DI SISTEMI OPERATIVI Università di Milano, a.a. 1996-97 INTRODUZIONE AL LINGUAGGIO JAVA Roberto Polillo (Queste slides sono una espansione delle slides di G.Prini per lo stesso corso) Introduzione al linguaggio Java 1
Slide 2: RIFERIMENTI The Java Series (Addison-Wesley): • K.Arnold, J.Gosling, The Java Programming Language • J.Gosling, B:Joy, G:Steel, The Java Language Specification • T.Lindholm, F.Yellin, The Java Virtual Machine Specification • ….. Introduzione al linguaggio Java 2
Slide 3: INDICE Parte 1 Parte 2 Parte 3 Introduzione al sistema di programmazione Java Programmazione a oggetti Il linguaggio Java Introduzione al linguaggio Java 3
Slide 4: PARTE 1 INTRODUZIONE AL SISTEMA DI PROGRAMMAZIONE JAVA Introduzione al linguaggio Java 4
Slide 5: CARATTERISTICHE Introduzione al linguaggio Java 5
Slide 6: CHE COS’È JAVA • È un linguaggio (e relativo ambiente di programmazione) definito dalla Sun Microsystems … • … per permettere lo sviluppo di applicazioni sicure, performanti e robuste su piattaforme multiple, in reti eterogenee e distribuite (Internet) Introduzione al linguaggio Java 6
Slide 7: IL LINGUAGGIO JAVA: CARATTERISTICHE • • • • • • • • • Semplice e orientato agli oggetti Interpretato Architetturalmente neutro e portabile Robusto Distribuito Sicuro Dinamico Ad elevate prestazioni Concorrente (multithread) Introduzione al linguaggio Java 7
Slide 8: SEMPLICE E OO • Sintassi simile a C e C++ (facile da imparare) • Elimina i costrutti più "pericolosi" di C e C++ – – – – – aritmetica dei puntatori (de)allocazione esplicita della memoria strutture (struct) definizione di tipi (typedef) preprocessore (#define) • Aggiunge garbage collection automatica • Conserva la tecnologia OO di base di C++ • Rivisita C++ in alcuni aspetti (C++--==) Introduzione al linguaggio Java 8
Slide 9: INTERPRETATO • Il compilatore produce un codice di tipo intermedio per una “Java Virtual Machine” (“bytecode”) ... • … che viene interpretato codice sorgente compilatore byte code interprete Introduzione al linguaggio Java 9
Slide 10: BYTECODE: ESEMPIO void spin ( ) { int i; for (i = 0; i < 100; i++) { ; } } 0 iconst_0 1 2 5 8 9 11 14 istore_1 goto 8 iinc 1 1 iload_1 bipush 100 if_icmplt 5 return // push int constant 0 // store into local 1 (i=0) // first time, don’t increment // increment local i by 1 (i++) // push local 1 (i) // push int constant (100) // compare, loop if < (I<100) // return void when done Introduzione al linguaggio Java 10
Slide 11: ARCHITETTURALMENTE NEUTRO • Il byte-code è indipendente dall’architettura hardware (ANDF: Architecture Neutral Distribution Format) • Pertanto, un programma bytecode può essere eseguito su qualsiasi sistema su cui giri un ambiente run-time Java Introduzione al linguaggio Java 11
Slide 12: ESEMPIO Sistema tradizionale compilatore macchina A codice sorgente compilatore macchina B ……. eseguibile macchina A eseguibile macchina B Sistema ANDF compilatore macchina A codice sorgente compilatore macchina B ……. byte code interprete macchina A interprete macchina B ……. Introduzione al linguaggio Java 12
Slide 13: ESEMPIO • Il formato dei dati è specificato esattamente, e non “di minima”, come nel C: – – – – – – – byte short int long float double char 8 bit complemento a 2 16 bit “ 32 bit “ 64 bit “ 32 bit IEEE 754 floating 64 bit “ 16 bit Unicode Introduzione al linguaggio Java 13
Slide 14: PORTABILE • Il sistema Java (compilatore + interprete + librerie run-time) è facilmente portabile su piattaforme diverse codice sorgente compilatore byte code interprete libreria S.O. – il compilatore Java è scritto in Java – l’ambiente run-time è scritto in ANSI C con interfacce standard (POSIX) verso il sistema operativo – nessuna “implementation dependency” Introduzione al linguaggio Java 14
Slide 15: ROBUSTO • Controlli estensivi a compile-time e a run-time, per rilevare gli errori quanto prima possibile (es.: type checking) • Per questo, le caratteristiche insicure di C e C++ sono rimosse: – Nessuna gestione esplicita dei puntatori (no aritmetica dei puntatori, no malloc e free esplicite, …) – Gestione della memoria con garbage collection – Array e stringhe “veri” • Verifica del byte-code a load-time Introduzione al linguaggio Java 15
Slide 16: DISTRIBUITO • Pensato per essere eseguito in rete • L’ambiente run-time incorpora funzioni di rete (sia di basso livello: TCP/IP, che di alto livello: HTTP, …) • La rete è facilmente accessibile (come i file locali) Introduzione al linguaggio Java 16
Slide 17: SICURO • L’ambiente di esecuzione si protegge da bytecode potenzialmente “ostile” • Esempi: – il bytecode viene verificato prima dell’interpretazione (“theorem prover”), in modo da essere certi di alcune sue caratteristiche – gli indirizzamenti alla memoria nel bytecode sono risolti sotto il controllo dell’interprete Introduzione al linguaggio Java 17
Slide 18: COMPILE-LOAD-RUN Sorgente Java Loader delle classi Verifica del byte-code Interprete Rete Compilatore Ambiente run-time Byte-code Java hardware Introduzione al linguaggio Java 18
Slide 19: ELEVATE PRESTAZIONI • La verifica del bytecode permette di saltare molti controlli a run-time: l’interprete è pertanto efficiente • Per maggiore efficienza, possibilità compilazione on-the-fly del bytecode in codice macchina Introduzione al linguaggio Java 19
Slide 20: COMPILAZIONE ON-THE-FLY Sorgente Java Loader delle classi Verifica del byte-code Interprete Rete Compilatore Ambiente run-time Byte-code Java Generatore di codice hardware Introduzione al linguaggio Java 20
Slide 21: DINAMICO • Il codice è eseguibile anche in assenza di alcuni moduli: • … le classi necessarie per la esecuzione di un programma Java possono essere caricate e collegate dinamicamente quando servono Esempio: nuove release di moduli caricabili automaticamente dalla rete quando servono Introduzione al linguaggio Java 21
Slide 22: CONCORRENTE • Multithreading parte integrante del linguaggio: – Applicazioni interattive più facili a scriversi – Migliore "reattività" (anche se non real-time) Esempio: caricamento asincrono di immagini nei browser di rete riduce i tempi di attesa Introduzione al linguaggio Java 22
Slide 23: RICCO La Standard Library Java contiene una ricca collezione di classi e di metodi preconfezionati: – – – – – Language support Utilities Input/output Networking Abstract Window Toolkit (AWT) Introduzione al linguaggio Java 23
Slide 24: JAVA E INTERNET Introduzione al linguaggio Java 24
Slide 25: WEB BROWSER E SERVER Server abc.com Client Server xyz.com Hyperlink Browser program to xyz.com Disk Disk HTTP used over this TCP connection HTTP Server HTTP Server Internet Introduzione al linguaggio Java 25
Slide 26: URL: Uniform Resource Locator <protocollo> :// <nome del server> <nome del file> Esempio: http://www.dsi.unimi.it/DSI/corsi/programmi/F28005/index.html deve essere risolto in un indirizzo internet (IP) con l’aiuto di un Domain Name Server (DNS) Introduzione al linguaggio Java 26
Slide 27: HTML: ESEMPIO <HTML> <HEAD> <TITLE> Esempio </TITLE> </HEAD> <BODY> <P> Testo <A HREF=“http://www.dsi.unimi.it”> DSI </A> </BODY> </HTML> Esempio Testo DSI Introduzione al linguaggio Java 27
Slide 28: APPLET JAVA • Sono programmi Java riferiti da link in pagine HTML • Vengono caricati e interpretati dal browser (se questo supporta Java) • Permettono di “animare” le pagine web Introduzione al linguaggio Java 28
Slide 29: HTML con APPLET: ESEMPIO <HTML> <HEAD> <TITLE> Esempio </TITLE> Esempio </HEAD> Testo <BODY> Hallo! <P> Testo <APPLET CODE=“HelloWorld.class WIDTH=300 HEIGHT=80> Qui c’è un applet che ti saluta </APPLET> testo che esce se il browser </BODY> non supporta gli applet </HTML> Introduzione al linguaggio Java 29
Slide 30: JAVA BROWSER rete TCP / IP http client ftp client java loader interprete HTML interprete JAVA I/O library local disk UI library Introduzione al linguaggio Java 30
Slide 31: UN NUOVO PARADIGMA: NETWORK COMPUTING Approccio tradizionale DATI RETE PROGRAMMI PC Network computing PROGRAMMI E DATI load and run RETE NC Introduzione al linguaggio Java 31
Slide 32: PARTE 2 PROGRAMMAZIONE A OGGETTI Introduzione al linguaggio Java 32
Slide 33: PARADIGMI DI PROGRAMMAZIONE Introduzione al linguaggio Java 33
Slide 34: RIFLESSIONI SULLA PROGRAMMAZIONE Programmare è un mestiere strano: costruire cose immateriali sempre piene di difetti, che costano un sacco di soldi e sono fatte di migliaia di frasi scritte da gente particolare per macchine molto stupide che richiedono precisione assoluta e che cambiano di continuo ... Introduzione al linguaggio Java 34
Slide 35: I DUE PARADIGMI DELLA PROGRAMMAZIONE Ci sono essenzialmente due modi diversi di descrivere il mondo: • come un sistema di processi (“modello procedurale”) • come un sistema di cose (“modello a oggetti”) Introduzione al linguaggio Java 35
Slide 36: ESEMPIO: UNA MACCHINA PER SPREMERE LE ARANCE Rube Goldberg, Inventions of Professor Lucifer Butts, 1932 Introduzione al linguaggio Java 36
Slide 37: IL MODELLO PROCEDURALE: ALCUNI TEMI TIPICI • • • • • • • • • • • • Processi, sequenze di esecuzione Concetto di “controllo” Trasformazioni, funzioni Flow-charts Tracciatori, program profilers Copertura topologica Complessità strutturale Il problema dei goto Linguaggi strutturati Programmazione top-down Astrazione procedurale …. Introduzione al linguaggio Java 37
Slide 38: LA MACCHINA DI VON NEUMANN “… nel progettare una sequenza codificata, quello che bisogna avere innanzitutto in mente non è l’apparenza originale della sequenza, ma piuttosto il suo funzionamento e il suo continuo cambiamento mentre il processo che essa controlla procede nel suo corso. … È dunque consigliabile incominciare la progettazione dalla fine, e cioè progettare per prima cosa il corso del processo e la relazione delle sue fasi successive con il codice che cambia, e quindi estrarre la sequenza codificata come operazione successiva.” Goldstine & Von Neumann, 1947 Introduzione al linguaggio Java 38
Slide 39: SPAGHETTI E STRUTTURA Introduzione al linguaggio Java 39
Slide 40: RIUSABILITÀ NEI LINGUAGGI PROCEDURALI Dalle librerie di “subroutines” alle librerie di procedure/funzioni Esempio: C int fun (int i, float r) { int j; …. } “ASTRAZIONE FUNZIONALE” Introduzione al linguaggio Java 40
Slide 41: IL MODELLO PROCEDURALE: LINGUAGGI Fortran Cobol Basic Pascal C 1956-1957 1960 1963-1964 1972 1972 Introduzione al linguaggio Java 41
Slide 42: UN BLOCCO INTELLETTUALE? “… Questi “linguaggi di Von-Neumann” creano dei blocchi stradali mentali enormi e non necessari nel pensare i programmi e nel creare le combinazioni di alto livello richieste da una metodologia di programmazione veramente potente. …” John Backus, 1978 Introduzione al linguaggio Java 42
Slide 43: IL MODELLO A OGGETTI: ALCUNI TEMI TIPICI • • • • • Dall’astrazione funzionale alla “data abstraction” Costruire “cose”, non processi Società di entità attive, cooperanti, riusabili Dalla computazione alla comunicazione e alla delega Classificare il mondo: classi, sottoclassi, istanze (“esemplari”) • Bottom-up, non top-down Introduzione al linguaggio Java 43
Slide 44: IL MODELLO A OGGETTI: LINGUAGGI Simula Smalltalk Eiffel C++ Java Introduzione al linguaggio Java 44
Slide 45: IL PARADIGMA A OGGETTI Introduzione al linguaggio Java 45
Slide 46: OGGETTI: CHE SONO MAI? • Versione informatica degli oggetti "reali" • Dotati di una loro propria "individualità" • Capaci di interagire per scambio di messaggi • Caratterizzati da proprietà – dati: ne descrivono lo “stato” – funzioni: ne descrivono il “comportamento” • Un msg modifica stato e attiva comportamenti Un oggetto è una coppia [stato,funzioni] Introduzione al linguaggio Java 46
Slide 47: ESEMPIO: UN’AUTOMOBILE Funzioni - Avviati - Fermati - Accelera -… Dati: - Targa - Colore - Velocità - Livello benzina - ... Introduzione al linguaggio Java 47
Slide 48: CLASSI • una classe ha un nome, e contiene due tipi di membri: campi e metodi metodo metodo campi metodo metodo “Tipo di dati astratti” (ADT) Introduzione al linguaggio Java 48
Slide 49: OGGETTI • Un oggetto è una istanza (“esemplare”) di una classe, che viene creato (“instanziato”) dinamicamente valori variabili MIV5678 a BO8956 Automobile b MIK1178 c Due esemplari della stessa classe sono distinguibili soltanto per il loro stato (il valore dei loro campi), mentre il comportamento è sempre identico Introduzione al linguaggio Java 49
Slide 50: CLASSI: ESEMPIO (JAVA) class Automobile { string targa; int velocità; color colore; … public void Avviati () { ….. } public void Fermati () { } } nome classe campi metodi Introduzione al linguaggio Java 50
Slide 51: OGGETTI: ESEMPIO (JAVA) class Automobile { …. } …. Automobile a, b, c; a = new Automobile(); b = new Automobile(); c = new Automobile(); …. a.Avviati(); …. Introduzione al linguaggio Java 51 dichiara, non crea crea
Slide 52: INCAPSULAMENTO • Alcuni attributi (dati e metodi) sono pubblici (cioè visibili "all'esterno") • Altri attributi sono privati dell'oggetto, e quindi “nascosti” all’esterno (“information hiding”) • Le parti private sono modificabili senza effetti per gli interlocutori dell'oggetto • Propagazione delle modifiche assai contenuta • Stimolo al riutilizzo di oggetti ("black-box") Introduzione al linguaggio Java 52
Slide 53: ESEMPIO: AUTOMOBILE • Parti "visibili" (interfaccia pubblica): accesso a "ciò che l'auto può fare" – volante, combinazione volante-freno (ev. a mano) – blocchetto di accensione, oppure manovella – pedale dell'acceleratore, acceleratore automatico • Parti "nascoste" (implementazione): "come l'auto fa ciò che si può fare" – meccanica dello sterzo e dell'alimentazione – elettromeccanica dell'avviamento – sistema di alimentazione e accensione Introduzione al linguaggio Java 53
Slide 54: INCAPSULAMENTO: APPROCCI • Approccio "puro" lo stato è privato, e lo si può modificare solo attraverso quei metodi che sono stati dichiarati pubblici . Esempio: Fermati() • Approccio di Java anche le componenti dello stato possono essere dichiarate pubbliche e modificate dall'esterno Esempio: velocita=0 Introduzione al linguaggio Java 54
Slide 55: INTERAZIONI TRA OGGETTI • Gli oggetti possono comunicare e interagire mediante scambio di messaggi attraverso le loro interfacce pubbliche (stato o funzioni) • Per mezzo di un messaggio un oggetto può chiedere un'informazione a un altro oggetto, causarne un cambiamento di stato, oppure delegargli un'attività • Un messaggio in arrivo viene trattato dal metodo omonimo del ricettore, il quale "si attiva" per rispondere, per cambiare di stato, oppure per intraprendere un'attività Introduzione al linguaggio Java 55
Slide 56: ESEMPIO: UN'AUTOVETTURA • Il sistema antiskid durante una frenata invia periodicamente un messaggio alle ruote per "leggere" la loro velocità di rotazione • Il galleggiante nel serbatoio del carburante invia messaggi all'indicatore di livello sul cruscotto per "scrivervi" un nuovo stato • Il volante tornando alla posizione di riposo invia un messaggio al comando meccanico dell'indicatore di direzione per delegargli il compito di interrompere l'eventuale segnale lampeggiante (i.e. di "togliere la freccia") Introduzione al linguaggio Java 56
Slide 57: OGGETTI COMPOSTI Un oggetto può essere costituito da altri oggetti automobile ruota carrozzeria motore Introduzione al linguaggio Java 57
Slide 58: UN SISTEMA A OGGETTI chiamata di un metodo di b main b a c d e g f Introduzione al linguaggio Java 58
Slide 59: SISTEMI A OGGETTI • Società di entità attive, cooperanti, riusabili • Bottom-up, non top-down • Visione locale, non globale • “Comportamento emergente” Introduzione al linguaggio Java 59
Slide 60: ESEMPIO: ARTIFICIAL LIFE Introduzione al linguaggio Java 60
Slide 61: UNA DOMANDA IMPORTANTE I computer possono fare di più di quanto venga loro indicato? Introduzione al linguaggio Java 61
Slide 62: EREDITARIETÀ • È il meccanismo che consente di derivare una sottoclasse da una classe data • Una sottoclasse si ottiene per aggiunta, per occultamento o per ridefinizione di uno o più membri rispetto alla classe di partenza (che diventa una superclasse della nuova classe) Esempio: StartTassametro EndTassametro Licenza automobile Introduzione al linguaggio Java 62 taxi
Slide 63: ESEMPIO class Taxi extends Automobile { int licenza; public void StartTassametro() { … } public void EndTassametro () { … } } nuovo campo nuovi metodi Introduzione al linguaggio Java 63
Slide 64: ESEMPI • Implementazione di un'interfaccia grafica – classe "finestra": attributo privato "sfondo" e metodo "cambiasfondo" – sottoclasse "finestra-nera": attributo privato "sfondo" ridefinito con il valore costante "nero", metodo "cambia-sfondo" occultato • Libreria di algebra lineare: – classe "matrice": metodo "determinante" generico – sottoclasse "matrice-diagonale": metodo "determinante" che moltiplica tra di loro gli elementi sulla diagonale • Dichiarazione dei redditi – classe "contribuente": quadri del modello 740 base – classe "autonomi": aggiunta del membro "quadro-E" Introduzione al linguaggio Java 64
Slide 65: GERARCHIA DI CLASSI Generalizzazione Specializzazione instanziazione Introduzione al linguaggio Java 65
Slide 66: ESEMPIO obiect Veicolo VeicoloSenza Motore Veicolo A Motore Motocicletta Automobile Taxi Introduzione al linguaggio Java 66
Slide 67: AGGIUNGERE SOTTOCLASSI obiect Veicolo VeicoloSenza Motore Veicolo A Motore Motocicletta Automobile Altro Taxi Introduzione al linguaggio Java 67
Slide 68: RIDEFINIZIONE DEI METODI Veicolo A Motore Noleggia Motocicletta Automobile Aereo Noleggia ereditano il metodo utilizza la versione locale Introduzione al linguaggio Java 68
Slide 69: POLIMORFISMO “Ciò che vale per una classe, vale anche per le sue sottoclassi. Se una proprietà viene ridefinita, quando la uso viene selezionata la versione corretta” Esempio: Quando uso un metodo di un oggetto, non so: • a quali livelli è definito • quale tra i metodi omonimi nella gerarchia verrà usato Introduzione al linguaggio Java 69
Slide 70: VISIBILITÀ DEI NOMI nome gerarchia di classi Il msg inviato all’oggetto risale nella gerarchia fino a trovare una definizione oggetto b Introduzione al linguaggio Java 70 b.nome oggetto a
Slide 71: PROGRAMMAZIONE A OGGETTI E TASSONOMIA Nel paradigma a oggetti, l’attenzione del programmatore è spostata dalla creazione di processi di computazione alla creazione di tassonomie del sistema in esame Osservazioni: • Per descrivere un sistema sono possibili tassonomie diverse, a seconda degli obbiettivi • La tassonomia è un’arte difficile Introduzione al linguaggio Java 71
Slide 72: ESEMPI ALTERNATIVI Automobile Automobile Spider Berlina Benzina Diesel Segmento A Segmento B Segmento C Introduzione al linguaggio Java 72
Slide 73: EREDITARIETÀ MULTIPLA • Meccanismo che consente di derivare sottoclassi da due o più classi Automobile Mezzo Pubblico Taxi • Il problema degli omonimi • Java non implementa ereditarietà multipla Introduzione al linguaggio Java 73
Slide 74: RIUSO Classi specifiche sviluppo interno Classi specializzate dal fornitore di classi Classi generali col linguaggio Linguaggio Introduzione al linguaggio Java 74
Slide 75: PARTE 3 IL LINGUAGGIO JAVA Introduzione al linguaggio Java 75
Slide 76: INDICE • • • • • • • • • Caratteristiche lessicali Tipi Strutture di controllo Classi Ereditarietà Interfacce Packages Struttura di un’applicazione Multithreading Introduzione al linguaggio Java 76
Slide 77: CARATTERISTICHE LESSICALI Introduzione al linguaggio Java 77
Slide 78: ALFABETO • I sorgenti Java utilizzano il codice standard internazionale a 16 bit Unicode, che comprende gli alfabeti più diffusi: arabo, greco, ebraico, cirillico, thai, katakana, hiragana, cinese, coreano, e molti altri (http://www.unicode.org) • I programmi Java possono essere scritti con altre codifiche (es. ASCII), ma devono essere convertiti in Unicode prima di essere compilati • Sequenze di escape: /udddd (d: 0-9, a-f, A-F) Introduzione al linguaggio Java 78
Slide 79: FORMATO • Il formato di un sorgente Java è libero: gli spazi (blank, tab, newline, form feed) non sono significativi, tranne che per separare i token fra loro, o nei letterali Introduzione al linguaggio Java 79
Slide 80: COMMENTI Tre diversi stili: • /* Commento tradizionale, eventualmente su più linee, non nidificato */ • // Commento su di una sola linea • /** Commento di documentazione". */ Solo immediatamente prima di una dichiarazione di classe, interfaccia, metodo o campo, e viene incluso nella documentazione generabile automaticamente a partire dal codice sorgente (es.: javadoc) Introduzione al linguaggio Java 80
Slide 81: ESEMPIO /** Questo è un esempio di commento di documentazione per una classe “Automobile” * @see Ruota * @see Carrozzeria * @author Roberto * @version 1.0 */ Introduzione al linguaggio Java 81
Slide 82: TAGS Tag @see @author @version @param @return @exception Descrizione Nome di classe collegata Nome autore Versione Nome e descrizione parametro Descrizione del valore di ritorno Nome e descrizione eccezione Si applica a Classe, metodo, campo Classe Classe Metodo Metodo Metodo Introduzione al linguaggio Java 82
Slide 83: IDENTIFICATORI • Sono composti da “lettere Java” e “cifre Java”, e devono iniziare con una “lettera Java” • Possono essere di qualsiasi lunghezza • Attenzione: – sono lettere e cifre Unicode! – _ e $ sono considerate lettere – caratteri con codifica diversa (es. maiuscole e minuscole) sono considerati diversi (anche se hanno la stessa rappresentazione) Introduzione al linguaggio Java 83
Slide 84: PAROLE CHIAVE Le seguenti keywords non possono essere usate come identificatori: abstract double int super boolean else interface switch break extends long synchronized byte final native this case finally new throw catch float package throws char for private transient class (goto) protected try (const) if public void continue implements return volatile default import short while do instanceof static Note: - const e goto sono riservate, ma non usate - anche i letterali null, true, false sono riservati Introduzione al linguaggio Java 84
Slide 85: KEYWORDS JAVA E C Java C struct union enum signed unsigned extern auto register sizeof typedef char int short long float double void if else for while do switch case default break continue return goto°° volatile static const°° byte boolean final try catch finally throw throws private public protected transient synchronized native abstract import class extends instanceof implements interface package this super new true° false° null° ° letterali, non keywords °° riservate ma non usate in Java Introduzione al linguaggio Java 85
Slide 86: TIPI Introduzione al linguaggio Java 86
Slide 87: TIPI: SINTESI TIPI boolean: Primitivi numerici interi KEYWORD boolean byte short int long char float double class interface NOTE true, false 8 bit interi in compl. a 2 16 bit 32 bit 64 bit 16 bit Unicode 32 bit IEEE 754 64 bit floating-point Reference classi interfacce array Null Introduzione al linguaggio Java 87
Slide 88: TIPI (segue) • Linguaggio fortemente tipato: il tipo di una espressione è sempre noto a compile-time • Linguaggio a oggetti non puro: non tutti i tipi sono classi • Rispetto al C, non esistono: signed, unsigned, long double, enum, puntatori, struct, union, typedef Introduzione al linguaggio Java 88
Slide 89: TIPI PRIMITIVI: ESEMPI • Dichiarazioni: int i, float f; • Inizializzazioni: double d = 3.14; • Espressioni: i+5 Essenzialmente, gli j = i++ stessi operatori del C Nota: byte e short vengono sempre promossi a int prima di essere valutati • Assegnamenti: i = j + 5; Introduzione al linguaggio Java 89
Slide 90: CLASSI dichiarazione di classe: class Automobile { <campi> <metodi> } dichiarazione di oggetto: Automobile a; creazione di oggetto: a nul I campi vengono inizializzati a a = new Automobile(); uso dell’oggetto: … a.campo … … a.metodo(…) ... Introduzione al linguaggio Java 90 heap
Slide 91: CLASSI: ESEMPIO class Safe { public int private boolean private int doorNumber = 123; locked = true; combination = 456; 123 public boolean isLocked() { return (locked) } Safe aSafe; public void unLock (int thisCombination) { aSafe = new Safe(); if (thisCombination == combination) unLock(); } Safe anotherSafe; private void unLock() { anotherSafe = new Safe(1927) locked = false; ... } aSafe.doorNumber=456; private void setCombination(int setting) { aSafe.unLock(1997); combination = setting; } Safe() { } /* costruttore */ Safe (int door) { /* altro costruttore (overloading) */ doorNumber = door; setCombination(doorNumber); } } Introduzione al linguaggio Java 91
Slide 92: CLASSI “WRAPPER” • Tutti i tipi primitivi tranne byte e short hanno una classe corrispondente nel package java.lang: Boolean, Integer, Long, Character, Float, Double, (“wrapper class”) • Tale classe definisce metodi e costanti utili per quel tipo, ad esempio: Classe: Character Costanti (static): MIN_VALUE, MAX_VALUE, … Metodi (static): isDefined, isLowerCase, IsUpperCase, isTitleCase, isDigit, isLetter, isLetterOrDigit, isSpace, isJavaLetter,isJavaLetterOrDigit, toLowerCase, toUpperCase, toTitleCase, digit, forDigit Introduzione al linguaggio Java 92
Slide 93: INTERFACCE • In sostanza, sono liste di metodi di cui non è definita l’implementazione, ma solo l’interfaccia • La loro implementazione deve essere realizzata da una classe Introduzione al linguaggio Java 93
Slide 94: ESEMPIO 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 Introduzione al linguaggio Java 94
Slide 95: ARRAY • In Java gli array sono oggetti • I componenti di un array: – sono tutti dello stesso tipo – possono essere di tipo primitivo o reference (inclusi altri array) – sono indicizzati con int (indice primo elemento: 0), con controllo di validità degli indici a run-time • Esempio: int[ ] a; /* dichiarazione */ /* anche int a[ ]; */ a = new int[3]; /* creazione */ a[0] = 0; /* uso */ a a null heap Introduzione al linguaggio Java 95
Slide 96: ARRAY (segue) • La lunghezza di un array è fissata al momento della sua creazione, e non può essere cambiata… • ... ma si può assegnare un nuovo array di diversa lunghezza all’array reference: a int[ ] a = new int[3]; a heap a = new int[5]; heap Introduzione al linguaggio Java 96
Slide 97: ARRAY DI ARRAY short [ ] [ ] a; short a[ ] [ ]; /* array di array di short */ /* equivalente */ a a[2] [0] a = new short [3][2]; heap a a = new short [3][ ]; heap null null null Introduzione al linguaggio Java 97
Slide 98: ARRAY DI OGGETTI class Automobile { public int targa; public int velocità; …. } …. Automobile[ ] a=new Automobile[3]; a heap a[2].targa Introduzione al linguaggio Java 98
Slide 99: STRUTTURE DI CONTROLLO Introduzione al linguaggio Java 99
Slide 100: STRUTTURE DI CONTROLLO: SINTESI Sequenza Selezione Iterazione Salto Gestione eccezioni if switch for while do-while break continue return uscita da un blocco continua un loop da un metodo Non c’è goto! try-catchfinally-throw Introduzione al linguaggio Java 100
Slide 101: SINTASSI boolean, non integer! if ( condition ) statement; [else statement; ] switch ( intexpr ) { case intexpr : statement; [case intexpr : statement; ... default : statement; ] } while ( condition ) statement; do statement; while ( condition ); Introduzione al linguaggio Java 101 for ( init; condition; increment ) statement;
Slide 102: USCITE • break [label]; • continue [label]; • return expr; • label: statement Introduzione al linguaggio Java 102
Slide 103: ESEMPIO label: for (i =0 , j=0 ; i<10 && j<20; i++ , j++) { for (z=0 ; z<100 ; z++) { switch (expr) { case tag: statements; break; /* esce da switch */ ..... default: statements; break label; /* esce da label */ } if (z==15) continue; /* prosegue il for z */ if (z==i+j) continue label; /* prosegue da label */ } } Introduzione al linguaggio Java 103
Slide 104: GESTIONE ECCEZIONI • È una struttura di controllo che permette la gestione di condizioni di errore senza complicare la struttura del codice (codici di ritorno, flag, …) • Quando si rileva una condizione anomale (eccezione), essa viene segnalata (throw), e il controllo viene automaticamente trasferito al gestore della eccezione, che la tratta Introduzione al linguaggio Java 104
Slide 105: STRUTTURA try-catch-finally try blocco-0 catch (exception_type1 id) blocco-1 catch (exception_type2 id) block-2 … finally blocco-n qui dentro viene segnalata la eccezione, con throw e blocco-0 exception_type1 exception_type2 blocco-1 blocco-2 blocco-n Introduzione al linguaggio Java 105
Slide 106: LA SEGNALAZIONE DELLE ECCEZIONI Le eccezioni possono venire segnalate: • dal sistema run-time, es.: ArithmeticException IndexOutOfBoundsException SecurityException NullPointerException ... • dal programma: throw e; Introduzione al linguaggio Java 106
Slide 107: CHE COSA SONO LE ECCEZIONI • Le eccezioni sono oggetti, di una sottoclasse della classe Throwable: Object Throwable Exception Error Runtime Exception unchecked exceptions unchecked exceptions checked exceptions, definite dall’utente Introduzione al linguaggio Java 107
Slide 108: LA DICHIARAZIONE throws type method(args) throws MyException { …. throw new MyException(…) …. } •Permette al compilatore di controllare quali eccezioni vengono segnalate • fornisce documentazione all’utente del metodo Introduzione al linguaggio Java 108
Slide 109: CLASSI Introduzione al linguaggio Java 109
Slide 110: DICHIARAZIONE DI CLASSI [Doc comment] [Modifiers] class ClassName [ extends SuperClassName] [ implements InterfaceName [, InterfaceName] ...] {ClassBody} Doc comment Modifiers extends implements ClassBody commento di documentazione abstract, final, public, ... la classe è sottoclasse di un'altra la classe realizza una o più interfacce i campi e i metodi della classe Introduzione al linguaggio Java 110
Slide 111: ESEMPIO Dichiarazione di una classe MyClass public class MyClass { int i; public void Add_to_i (int j) { i = i+j; } public MyClass () { i = 10; } } MyClass mc; mc = new MyClass(); mc.i++; mc.Add_to_i(10); /* campo */ /* metodo */ /* metodo costruttore: ha lo stesso nome della classe */ Creazione e uso di una istanza di MyClass /* dichiarazione, non creazione */ /* creazione: l'attributo i vale 10 */ /* ora i vale 11 */ /* e ora i vale 21 */ Introduzione al linguaggio Java 111
Slide 112: DICHIARAZIONE DI CAMPI [DocComment] [Modifiers] Type VariableDeclarator [,VariableDeclarator]… ; Esempio: Doc comment Modifiers Type VariableDeclarator static int i = 5, j = 7, a[]; commento di documentazione static, public, protected,private, final, ... tipo (primitivo o reference) identificatore (anche di array), con eventuale inizializzazione Introduzione al linguaggio Java 112
Slide 113: DICHIARAZIONE DI METODI [Doc comment] [Modifiers] ReturnType MethodName (ParameterList) [throws ClassType [,ClassType] … ] { MethodBody } Doc comment Modifiers ReturnType commento di documentazione static, public,protected,private, abstract, final,native, ... può essere un tipo primitivo o reference, o void (nessun valore di ritorno). Deve essere sempre specificato (ma non per i costruttori) un metodo ha sempre un numero fisso di argomenti (ma è possibile l’ overloading) Introduzione al linguaggio Java 113 ParameterList
Slide 114: ESEMPIO int base; public int power (int n) { int i, p; p=1; for (i=1; i<=n; ++i) p=p*base; return p; } campo della classe variabili locali valore della funzione Introduzione al linguaggio Java 114
Slide 115: IL MODIFICATORE static • Campi e metodi dichiarati static, sono associati alla classe e non a una particolare istanza class MyClass { static int a; … static void MyMethod() { a = a+1; } } • Pertanto: esiste una sola copia di un campo statico, condiviso da tutte le istanze della classe; non occorre istanziare un oggetto per usare un membro statico; metodi statici possono accedere solo a membri statici della classe • Sono qualificati con il nome della classe, e non della istanza MyClass.a =MyClass.a + 1; Introduzione al linguaggio Java 115
Slide 116: ESEMPIO class Safe { static int LastSerialNumber; Il costruttore Safe fa sì che public int SerialNumber; ogni istanza di Safe abbia un int SetCombination; SerialNumber unico …. Safe(int Combination) { SerialNumber = LastSerialNumber++; SetCombination = Combination; } public static StartNewSeriesFrom (int Start) { LastSerialNumber = Start; } } …. Safe.LastSerialNumber(100000); /* inizializza il numero di serie */ Safe MySafe = new Safe(23456); /* crea una Safe di SerialNumber = 100001 e combinazione 23456 */ … MySafe.SerialNumber …. Introduzione al linguaggio Java 116
Slide 117: VARIABILI LOCALI • Le variabili locali a un metodo: – sono visibili solo dal corpo del metodo – vengono allocate (nello stack di run-time) alla chiamata e deallocate all’uscita del metodo – non vengono inizializzate automaticamente (diversamente dai campi di una classe) • Non si può accedere a una variabile a cui non si sia prima assegnato un valore (e viene segnalato in compilazione !) Esempio: int i; if ( cond ) { i = 55; … } i++; /* compile-time error */ Introduzione al linguaggio Java 117
Slide 118: LA KEYWORD this • Se una variabile locale ha lo stesso nome di un membro della sua classe, questo risulta invisibile (“shadowing”) … • … a meno di usare la keyword this, che denota l’oggetto corrente Esempio: class MyClass { int x, y, z; void MyMethod (int x) { int y; y=x+1; z=this.x; … /* membri */ /* parametro */ /* variabile locale */ /* y è la variabile locale, x è il parametro */ /* this.x è il membro x */ } NB: Poichè this denota un oggetto, non si può usare con membri dichiarati static Introduzione al linguaggio Java 118
Slide 119: PASSAGGIO DI PARAMETRI A UN METODO • Tutti i tipi primitivi sono passati per valore • Anche i riferimenti a oggetti di tipo reference sono passati per valore Es: int i; i SomeObject obj = new SomeObject(); obj MyMethod( i, obj ); …. o Void MyMethod (int j, SomeObject o) { j j = j+1; /* non altera i, passato per valore */ o = null; /* non altera obj, che si riferisce ancora all’oggetto */ } Introduzione al linguaggio Java 119 heap
Slide 120: COSTRUTTORI • Sono metodi che vengono chiamati quando si crea una istanza di una classe; non ritornano alcun valore • Se non definisco alcun costruttore, per default viene fornito il costruttore vuoto: class MyClass { … MyClass() { } } • Possono essere overloaded; non ha senso che siano static Introduzione al linguaggio Java 120
Slide 121: ESEMPIO: OVERLOADING Dichiarazione di una classe MyNewClass public class MyNewClass { int i; public MyNewClass () { i = 10; } public MyNewClass (int j) { i = j; } } ..... Overloading: metodi omonimi devono essere distinguibili per la quantità e/o per il tipo degli argomenti Creazione di una istanza di MyNewClass MyNewClass mc0, mc1; mc0 = new MyNewClass(); mc0.i++; mc1= new MyNewClass(20); mc1.i++; /* dichiarazione, non creazione */ /* creazione: l'attributo i vale 10 */ /* ora i vale 11 */ /* creazione: l'attributo i vale 20 */ /* ora i vale 21 */ Introduzione al linguaggio Java 121
Slide 122: DISTRUZIONE DI OGGETTI • Java non supporta distruttori di oggetti: gli oggetti non possono essere distrutti esplicitamente • Un oggetto privo di riferimenti incidenti non è più accessibile, e la memoria che esso occupa può essere "riciclata" dal garbage collector, che opera in un thread indipendente a bassa priorità String s; s = new String ("abc"); s = "def"; /* dichiarazione, non creazione */ /* creazione: s punta a "abc" */ /* "abc" non è più puntata da s */ Introduzione al linguaggio Java 122
Slide 123: FINALIZZATORI DI OGGETTI • Un oggetto "riciclabile" (cioè privo di puntatori incidenti) potrebbe trovarsi in uno stato poco "pulito" (ad es. potrebbe aver aperto dei file che non sono stati ancora chiusi) • Prima di riciclarlo, il garbage collector invoca il metodo finalize dell’oggetto, es.: protected void finalize () throws Throwable { ... super.finalize(); /* meglio metterlo sempre */ } • Il metodo finalize esiste sempre: se non è stato definito, viene ereditato da Object; Introduzione al linguaggio Java 123
Slide 124: IL MODIFICATORE native • Un metodo è dichiarato native quando il suo codice è dipendente dalla piattaforma (ad esempio, è scritto in un altro linguaggio) Esempio: public native void seek(long pos) throws IOException ; non deve essere specificato il body Introduzione al linguaggio Java 124
Slide 125: EREDITARIETA’ Introduzione al linguaggio Java 125
Slide 126: SOTTOCLASSI • In Java, una classe può estendere una sola altra classe (ereditarietà singola) • Una sottoclasse eredita i campi e i metodi della sua superclasse che non siano dichiarati private e che non siano costruttori, e li può usare come se fossero dichiarati al suo interno • Un oggetto di una sottoclasse può essere usato ovunque può essere usato un oggetto della sua superclasse Introduzione al linguaggio Java 126
Slide 127: ESEMPIO class Animale { Gatto Fufi = new Gatto(); float Peso; Animale creatura = Fufi; … void Mangia () { … } lecito, perchè “gatto” … è una sottoclasse } di “animale” class Mammifero extends Animale { int BattitoCardiaco; // eredita Peso … void Respira() { … } // eredita mangia … } class Gatto extends Mammifero { // eredita BattitoCardiaco, Peso, Mangia, Respira void FaLeFusa() { … } } Introduzione al linguaggio Java 127
Slide 128: “COME” ESTENDERE UNA CLASSE • Attenzione alla differenza fra la relazione “è un” e la relazione “ha un” : solo la prima può definire una sottoclasse Esempio: Un cerchio può essere definito mediante il suo centro e il suo raggio, ma sarebbe scorretto definire una classe cerchio come sottoclasse di punto: class punto { class cerchio extends punto { double x; int y; double raggio; … ... } } Introduzione al linguaggio Java 128
Slide 129: SHADOWING E OVERRIDING • shadowing • overriding un campo di una sottoclasse può “nascondere” un campo omonimo di una sua superclasse un metodo di una sottoclasse può “sovrascrivere” un metodo di ugual “segnatura” e ugual ReturnType di una sua superclasse class SuperClass { nasconde int i; sovrascrive void m(int k) {…} … } class Subclass extends Superclass { long i: void m(int n) {…} … } Introduzione al linguaggio Java 129 Esempio:
Slide 130: POLIMORFISMO class Animale { … void Mangia () { … } … } class Mammifero extends Animale { … } class Gatto extends Mammifero { … void Mangia() { … } ... } Gatto Fufi = new Gatto(); Animale creatura =Fufi; creatura.Mangia(); viene eseguito il metodo Mangia della classe Gatto! (binding dinamico: il metodo da chiamare viene selezionato a run-time) Introduzione al linguaggio Java 130
Slide 131: LA KEYWORD super • per denotare un membro nascosto (campo shadowed o metodo overridden non static), si può usare la keyword super Esempio: class SuperClass { int i; … } class Subclass extends SuperClass { long i: … i = super.i +1; … } Introduzione al linguaggio Java 131
Slide 132: CASTING Gatto Fufi = new Gatto(); Animale creatura; ... creatura = Fufi; /* ok */ Fufi = creatura; /* errore di compilazione: tipi incompatibili */ Fufi = (Gatto)creatura; /* ok, ma solo perchè creatura è un gatto: se non lo fosse, il controllo a run-time segnalrebbe una eccezione */ Introduzione al linguaggio Java 132
Slide 133: COSTRUTTORI NELLE SOTTOCLASSI Nel costruttore di una sottoclasse, è corretto, come prima cosa, chiamare il costruttore della superclasse Esempio: class SubClass extends SuperClass { SubClass() { super(); <altre operazioni> } } Introduzione al linguaggio Java 133
Slide 134: IL MODIFICATORE abstract • Una classe è dichiarata abstract quando contiene almeno un metodo abstract (cioè senza body) • Una classe abstract non può essere instanziata: occorre sovrascrivere tutti i metodi abstract in una sottoclasse, e istanziare la sottoclasse Esempio: abstract class a { … abstract int m(int k); } class b extends a { ... int m(int n) { … } } Introduzione al linguaggio Java 134 sovrascrive, fornendo la implementazione del metodo
Slide 135: IL MODIFICATORE final final ha tre significati diversi: • campo final non può essere modificato: è un campo costante (deve essere inizializzato) Esempio: final int i = 5; non può essere sovrascritto non può avere sottoclassi (quindi i suoi metodi sono implicitamente final) • metodo final • classe final Introduzione al linguaggio Java 135
Slide 136: METODI final: ESEMPIO class Password { private int passwd; final boolean validatePassword(String s) { ….. se non fosse final , potrebbe essere sovrascritto ! } ... } Introduzione al linguaggio Java 136
Slide 137: INTERFACCE Introduzione al linguaggio Java 137
Slide 138: INTERFACCE Una interface è una struttura sintattica dotata di nome, che racchiude la specifica della segnatura e del ReturnType dei metodi di una classe non ancora implementata Esempio: interface Driveable { boolean startEngine(); void stopEngine(); float accelerate(float acc); boolean turn(Direction dir); } Introduzione al linguaggio Java 138
Slide 139: IMPLEMENTAZIONE DI UNA INTERFACCIA Una interfaccia può essere implementata da una (o più) classi: interface Driveable { boolean startEngine(); ... } interface Automobile implements Driveable { boolean startEngine() { ... } // una particolare implementazione …. } interface Motorcycle implements Driveable { boolean startEngine() { ... } // un’altra implementazione …. } Introduzione al linguaggio Java 139
Slide 140: POLIMORFISMO Esempio: Driveable vehicle; /* variabile di tipo interfaccia; le possiamo assegnare qualunque oggetto di una classe che implementa l’interfaccia */ Automobile auto = new Automobile(); Motorcycle moto = new Motorcycle(); ... vehicle = auto; vehicle.startEngine(); /* polimorfismo: è il metodo di Automobile */ … vehicle = moto; vehicle.startEngine(); /* polimorfismo: è il metodo di Motorcycle */ Introduzione al linguaggio Java 140
Slide 141: EREDITARIETA’ MULTIPLA Una classe può implementare più di una interfaccia interface Driveable { void startEngine(); void stopEngine(); float accelerate(float acc); boolean turn(Direction dir); } interface Rentable { void startRental(); void endRental(); int book(Date start, Date end); } class AvisCar implements Driveable, Rentable { void startEngine() { … } void startRental() { … } … } Introduzione al linguaggio Java 141
Slide 142: SUPERINTERFACCE • Una interfaccia può estendere una o più altre interfacce, es.: interface a extends b, c, d { …. } • Ogni classe che implementa un’interfaccia deve estendere anche tutte le sue superinterfacce Introduzione al linguaggio Java 142
Slide 143: INTERFACCE vs CLASSI abstract • Le interfacce sono simili a classi che abbiano soltanto: – metodi abstract – campi static e final (cioè costanti) • A differenza delle classi, le interfacce permettono di realizzare una forma di ereditarietà multipla Introduzione al linguaggio Java 143
Slide 144: PACKAGES Introduzione al linguaggio Java 144
Slide 145: PACKAGES • Più classi o interfacce interrelate possono essere riunite in un package, dotato di nome Esempio: MyPackage classe o interfaccia c a b d e Introduzione al linguaggio Java 145
Slide 146: NOMI DI CLASSI • Il nome di una classe (o di una interfaccia) va sempre qualificato con il nome del package a cui appartiene, tranne quando viene usato all’interno dello stesso package Esempio: aaa.bbb.ccc.MyClass all’interno di aaa.bbb.ccc basta questo Introduzione al linguaggio Java 146
Slide 147: NOMI DI PACKAGE • Il nome di un package può essere composto da più identificatori separati da “.”: roberto.utilities.internet • Per evitare che package di produttori diversi abbiano lo stesso nome, si suggerisce di far iniziare il nome del package con il dominio Internet del produttore (invertito, e con il nome di più alto livello tutto maiuscolo): IT.unimi.dsi.roberto.utilities.internet nome di dominio Introduzione al linguaggio Java 147
Slide 148: PACKAGES STANDARD java.lang java.io java.util java.net java.applet java.awt classi base del linguaggio (Object, Thread, Throwable, System, String, Math, wrapper classes, …) classi di I/O (FileInputStream, FileOutputStream, ) classi di utilità (Date, Random, …) classi di supporto alle applicazioni di rete (socket, URL, …) classe Applet, … Abstract Windowing Toolkit Introduzione al linguaggio Java 148
Slide 149: LO STATEMENT package • Specifica che le classi che seguono appartengono a un certo package • Deve apparire (una sola volta) all’inizio di una unità di compilazione Esempio: a.java package p; class a {.. le classi a,b,c appartengono al package p Se lo statement è omesso, la classe appartiene al package anonimo class b {... class c {.. Introduzione al linguaggio Java 149
Slide 150: LO STATEMENT import • Per evitare di usare sempre nomi completi di classi, si può usare lo statement import Esempio: class MyClass { java.util.Date today; … } import java.util.Date; class MyClass { Date today; ... } Note: • import java.util.* importa tutte le classi del package java.util • java.lang.* è sempre importato implicitamente Introduzione al linguaggio Java 150