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
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
INDICE
Parte 1
Introduzione al sistema di programmazione Java
Parte 2
Programmazione a oggetti
Parte 3
Il linguaggio Java
Introduzione al linguaggio Java 3
PARTE 1
INTRODUZIONE AL SISTEMA DI
PROGRAMMAZIONE JAVA
Introduzione al linguaggio Java 4
CARATTERISTICHE
Introduzione al linguaggio Java 5
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
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
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
INTERPRETATO
• Il compilatore produce un codice di tipo
intermedio per una “Java Virtual Machine” (“bytecode”) ...
• … che viene interpretato
codice
sorgente
compilatore
byte code
Introduzione al linguaggio Java 9
interprete
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
Introduzione al linguaggio Java 10
// 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
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
ESEMPIO
Sistema tradizionale
eseguibile
macchina A
compilatore
macchina A
codice
sorgente
compilatore
macchina B
eseguibile
macchina B
…….
Sistema ANDF
compilatore
macchina A
codice
sorgente
compilatore
macchina B
interprete
macchina A
byte code
interprete
macchina B
…….
…….
Introduzione al linguaggio Java 12
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
PORTABILE
• Il sistema Java (compilatore + interprete + librerie
run-time) è facilmente portabile su piattaforme
diverse
codice
sorgente
compilatore
byte code
interprete
libreria
– 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
S.O.
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
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
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
COMPILE-LOAD-RUN
Loader
delle classi
Sorgente
Java
Verifica del
byte-code
Interprete
Rete
Compilatore
Ambiente
run-time
Byte-code
Java
hardware
Introduzione al linguaggio Java 18
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
COMPILAZIONE ON-THE-FLY
Loader
delle classi
Sorgente
Java
Verifica del
byte-code
Interprete
Rete
Generatore
di codice
Compilatore
Ambiente
run-time
Byte-code
Java
hardware
Introduzione al linguaggio Java 20
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
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
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
JAVA E INTERNET
Introduzione al linguaggio Java 24
WEB BROWSER E SERVER
Server abc.com
Server xyz.com
Client
Hyperlink
Browser
program
to xyz.com
Disk
HTTP used over
this TCP connection
Internet
Introduzione al linguaggio Java 25
Disk
HTTP
Server
HTTP
Server
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
HTML: ESEMPIO
<HTML>
<HEAD>
<TITLE> Esempio </TITLE>
</HEAD>
<BODY>
<P>
Testo
<A HREF=“http://www.dsi.unimi.it”> DSI </A>
</BODY>
</HTML>
Introduzione al linguaggio Java 27
Esempio
Testo
DSI
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
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
JAVA BROWSER
rete
TCP / IP
http
client
interprete
HTML
ftp
client
java
loader
interprete
JAVA
I/O
library
local disk
UI library
Introduzione al linguaggio Java 30
UN NUOVO PARADIGMA:
NETWORK COMPUTING
Approccio tradizionale
DATI
PROGRAMMI
RETE
PC
Network computing
PROGRAMMI E DATI
load
and run
RETE
NC
Introduzione al linguaggio Java 31
PARTE 2
PROGRAMMAZIONE A OGGETTI
Introduzione al linguaggio Java 32
PARADIGMI DI
PROGRAMMAZIONE
Introduzione al linguaggio Java 33
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
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
ESEMPIO: UNA MACCHINA PER
SPREMERE LE ARANCE
Rube Goldberg, Inventions of Professor Lucifer Butts, 1932
Introduzione al linguaggio Java 36
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
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
SPAGHETTI E STRUTTURA
Introduzione al linguaggio Java 39
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
IL MODELLO PROCEDURALE:
LINGUAGGI
Fortran
Cobol
Basic
Pascal
C
1956-1957
1960
1963-1964
1972
1972
Introduzione al linguaggio Java 41
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
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
IL MODELLO A OGGETTI:
LINGUAGGI
Simula
Smalltalk
Eiffel
C++
Java
Introduzione al linguaggio Java 44
IL PARADIGMA
A OGGETTI
Introduzione al linguaggio Java 45
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
ESEMPIO: UN’AUTOMOBILE
Funzioni
- Avviati
- Fermati
- Accelera
-…
Dati:
- Targa
- Colore
- Velocità
- Livello benzina
- ...
Introduzione al linguaggio Java 47
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
OGGETTI
• Un oggetto è una istanza (“esemplare”) di una
classe, che viene creato (“instanziato”) dinamicamente
valori
MIV5678
variabili
a
BO8956
Automobile
MIK1178
b
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
CLASSI: ESEMPIO (JAVA)
class Automobile {
string targa;
int velocità;
color colore;
…
public void Avviati () {
…..
}
public void Fermati () {
}
}
Introduzione al linguaggio Java 50
nome classe
campi
metodi
OGGETTI: ESEMPIO (JAVA)
class Automobile {
….
}
….
Automobile a, b, c;
a = new Automobile();
b = new Automobile();
c = new Automobile();
….
a.Avviati();
….
dichiara, non crea
crea
Introduzione al linguaggio Java 51
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
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
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
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
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
OGGETTI COMPOSTI
Un oggetto può essere costituito da altri oggetti
automobile
ruota
carrozzeria
Introduzione al linguaggio Java 57
motore
UN SISTEMA A OGGETTI
chiamata di un metodo di b
main
d
b
a
c
e
g
f
Introduzione al linguaggio Java 58
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
ESEMPIO: ARTIFICIAL LIFE
Introduzione al linguaggio Java 60
UNA DOMANDA IMPORTANTE
I computer possono fare di più di quanto venga
loro indicato?
Introduzione al linguaggio Java 61
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
taxi
Introduzione al linguaggio Java 62
ESEMPIO
class Taxi extends Automobile {
int licenza;
public void StartTassametro() {
…
}
public void EndTassametro () {
…
}
}
Introduzione al linguaggio Java 63
nuovo campo
nuovi metodi
ESEMPI
• Implementazione di un'interfaccia grafica
– classe "finestra": attributo privato "sfondo" e metodo "cambia-sfondo"
– 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
GERARCHIA DI CLASSI
Generalizzazione
Specializzazione
instanziazione
Introduzione al linguaggio Java 65
ESEMPIO
obiect
Veicolo
VeicoloSenza
Motore
Veicolo
A Motore
Motocicletta
Automobile
Taxi
Introduzione al linguaggio Java 66
AGGIUNGERE SOTTOCLASSI
obiect
Veicolo
VeicoloSenza
Motore
Veicolo
A Motore
Motocicletta
Automobile
Taxi
Introduzione al linguaggio Java 67
Altro
RIDEFINIZIONE DEI METODI
Veicolo A Motore
Noleggia
Motocicletta
Automobile
ereditano il metodo
Introduzione al linguaggio Java 68
Aereo
Noleggia
utilizza la versione locale
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
VISIBILITÀ DEI NOMI
nome
gerarchia di classi
Il msg inviato all’oggetto
risale nella gerarchia fino
a trovare una definizione
b.nome
oggetto b
Introduzione al linguaggio Java 70
oggetto a
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
ESEMPI ALTERNATIVI
Automobile
Automobile
Spider
Benzina
Berlina
Segmento A
Segmento B
Segmento C
Introduzione al linguaggio Java 72
Diesel
EREDITARIETÀ MULTIPLA
• Meccanismo che consente di derivare sottoclassi
da due o più classi
Mezzo
Pubblico
Automobile
Taxi
• Il problema degli omonimi
• Java non implementa ereditarietà multipla
Introduzione al linguaggio Java 73
RIUSO
Classi specifiche
Classi specializzate
Classi generali
Linguaggio
Introduzione al linguaggio Java 74
sviluppo interno
dal fornitore di classi
col linguaggio
PARTE 3
IL LINGUAGGIO JAVA
Introduzione al linguaggio Java 75
INDICE
•
•
•
•
•
•
•
•
•
Caratteristiche lessicali
Tipi
Strutture di controllo
Classi
Ereditarietà
Interfacce
Packages
Struttura di un’applicazione
Multithreading
Introduzione al linguaggio Java 76
CARATTERISTICHE LESSICALI
Introduzione al linguaggio Java 77
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
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
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
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
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
Introduzione al linguaggio Java 82
Si applica a
Classe, metodo, campo
Classe
Classe
Metodo
Metodo
Metodo
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
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
KEYWORDS JAVA E C
Java
C
struct union enum
signed unsigned
extern
auto register
sizeof typedef
byte boolean
final
char int short
long float double
void
if else for while do
switch case default
break continue
return goto°°
volatile
static const°°
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
TIPI
Introduzione al linguaggio Java 86
TIPI: SINTESI
TIPI
KEYWORD
boolean:
Primitivi
numerici
interi
floating-point
Reference
NOTE
boolean
true, false
byte
short
int
long
char
8 bit interi in compl. a 2
16 bit
32 bit
64 bit
16 bit Unicode
float
double
32 bit IEEE 754
64 bit
classi
class
interfacce
interface
array
Null
Introduzione al linguaggio Java 87
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
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
CLASSI
dichiarazione di classe:
class Automobile {
<campi>
<metodi>
}
dichiarazione di oggetto:
Automobile a;
a
nul
I campi vengono
inizializzati
creazione di oggetto:
a
a = new Automobile();
uso dell’oggetto:
… a.campo …
heap
… a.metodo(…) ...
Introduzione al linguaggio Java 90
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
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
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
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
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
null
a
heap
a[0] = 0; /* uso */
Introduzione al linguaggio Java 95
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];
heap
a
a = new int[5];
heap
Introduzione al linguaggio Java 96
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][ ];
null null
heap
Introduzione al linguaggio Java 97
null
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
STRUTTURE DI CONTROLLO
Introduzione al linguaggio Java 99
STRUTTURE DI CONTROLLO:
SINTESI
Sequenza
Selezione
if
switch
Iterazione
for
while
do-while
Salto
Gestione eccezioni
break
uscita da un blocco
continue
return
continua un loop
da un metodo
try-catchfinally-throw
Introduzione al linguaggio Java 100
Non c’è goto!
SINTASSI
boolean,
non integer!
if ( condition )
statement;
[else
statement; ]
switch ( intexpr ) {
case intexpr : statement;
[case intexpr : statement;
...
default : statement; ]
}
while ( condition )
statement;
for ( init; condition; increment )
statement;
do
statement;
while ( condition );
Introduzione al linguaggio Java 101
USCITE
• break [label];
• continue [label];
• return expr;
• label: statement
Introduzione al linguaggio Java 102
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
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
STRUTTURA try-catch-finally
qui dentro viene
segnalata la eccezione,
con throw e
try
blocco-0
catch (exception_type1 id)
blocco-1
catch (exception_type2 id)
block-2
…
finally
blocco-n
Introduzione al linguaggio Java 105
blocco-0
exception_type1
exception_type2
blocco-1
blocco-2
blocco-n
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
CHE COSA SONO LE ECCEZIONI
• Le eccezioni sono oggetti, di una sottoclasse
della classe Throwable:
Object
Throwable
Exception
Error
unchecked
exceptions
Runtime
Exception
unchecked
exceptions
checked exceptions,
definite dall’utente
Introduzione al linguaggio Java 107
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
CLASSI
Introduzione al linguaggio Java 109
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
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;
}
}
/* campo */
/* metodo */
/* metodo costruttore: ha lo
stesso nome della classe */
Creazione e uso di una istanza di MyClass
MyClass mc;
mc = new MyClass();
mc.i++;
mc.Add_to_i(10);
/* dichiarazione, non creazione */
/* creazione: l'attributo i vale 10 */
/* ora i vale 11 */
/* e ora i vale 21 */
Introduzione al linguaggio Java 111
DICHIARAZIONE DI CAMPI
[DocComment] [Modifiers] Type
VariableDeclarator [,VariableDeclarator]… ;
Esempio:
static int i = 5, j = 7, a[];
Doc comment
Modifiers
commento di documentazione
static, public, protected,private,
final, ...
tipo (primitivo o reference)
identificatore (anche di array), con
eventuale inizializzazione
Type
VariableDeclarator
Introduzione al linguaggio Java 112
DICHIARAZIONE DI METODI
[Doc comment] [Modifiers] ReturnType MethodName (ParameterList)
[throws ClassType [,ClassType] … ] {
MethodBody
}
Doc comment
Modifiers
commento di documentazione
static, public,protected,private, abstract,
final,native, ...
ReturnType
può essere un tipo primitivo o reference, o
void (nessun valore di ritorno). Deve essere sempre specificato (ma non per i costruttori)
ParameterList
un metodo ha sempre un numero fisso di
argomenti (ma è possibile l’ overloading)
Introduzione al linguaggio Java 113
ESEMPIO
int base;
campo della classe
public int power (int n) {
int i, p;
p=1;
for (i=1; i<=n; ++i)
p=p*base;
return p;
}
Introduzione al linguaggio Java 114
variabili locali
valore della funzione
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
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
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
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
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:
i
int i;
SomeObject obj = new SomeObject();
obj
MyMethod( i, obj );
….
o
j
Void MyMethod (int j, SomeObject o) {
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
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
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
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
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
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
EREDITARIETA’
Introduzione al linguaggio Java 125
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
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
“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
SHADOWING E OVERRIDING
• shadowing
un campo di una sottoclasse può “nascondere” un campo omonimo di una sua
superclasse
• overriding
un metodo di una sottoclasse può “sovrascrivere” un metodo di ugual “segnatura”
e ugual ReturnType di una sua superclasse
Esempio:
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
POLIMORFISMO
class Animale {
…
void Mangia () { … }
…
}
class Mammifero extends Animale {
…
}
class Gatto extends Mammifero {
…
void Mangia() { … }
...
}
Gatto Fufi = new Gatto();
Animale creatura =Fufi;
creatura.Mangia();
Introduzione al linguaggio Java 130
viene eseguito il metodo
Mangia della classe Gatto!
(binding dinamico: il metodo
da chiamare viene selezionato
a run-time)
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
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
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
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
IL MODIFICATORE final
final ha tre significati diversi:
• campo final
• metodo final
• classe 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)
Introduzione al linguaggio Java 135
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
INTERFACCE
Introduzione al linguaggio Java 137
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
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
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
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
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
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
PACKAGES
Introduzione al linguaggio Java 144
PACKAGES
• Più classi o interfacce interrelate possono essere
riunite in un package, dotato di nome
Esempio:
classe o
interfaccia
MyPackage
c
b
a
d
Introduzione al linguaggio Java 145
e
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
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
PACKAGES STANDARD
java.lang
classi base del linguaggio
(Object, Thread, Throwable, System, String,
Math, wrapper classes, …)
java.io
classi di I/O
(FileInputStream, FileOutputStream, )
java.util
classi di utilità
(Date, Random, …)
java.applet
classi di supporto alle applicazioni di
rete (socket, URL, …)
classe Applet, …
java.awt
Abstract Windowing Toolkit
java.net
Introduzione al linguaggio Java 148
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 {..
class b {...
class c {..
Introduzione al linguaggio Java 149
le classi a,b,c appartengono
al package p
Se lo statement è omesso,
la classe appartiene al
package anonimo
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
PACKAGE E DIRECTORY
• Molti ambienti Java mappano i nomi dei package
sui pathname del file system (compilatore e class
loader)
Esempio:
aaa.bbb.ccc.MyClass
package
aaa/bbb/ccc/MyClass
classe
directories
pathname
Introduzione al linguaggio Java 151
file
CLASS PATH
• Per indicare al class loader da quale directory
partire per la mappatura può essere usata la
variabile di ambiente CLASSPATH
Esempio (Unix):
setenv CLASSPATH /classi : /usr/roberto/classi : .
java.lang.Math
nome completo della classe
/java.lang.Math.class
pathname assoluto
Introduzione al linguaggio Java 152
VISIBILITA’
Classi e interfacce
• sono visibili all’interno del package in cui sono
dichiarate; sono visibili all’esterno del package solo
se dichiarate public
public class a { …
public interface b { …
Membri (campi e metodi)
• sono visibili quando:
– la loro classe è visibile e
– il loro modificatore li rende visibili
Introduzione al linguaggio Java 153
più visibile
VISIBILITA’ DI CAMPI E METODI
Modificatore
private
nessuno (default)
protected
public
Visibilità
solo nella classe in cui è definito
solo nelle classi del package
classi nel package e sottoclassi
(stesso package o altri package)
tutte le classi
NB: I membri di una interfaccia sono sempre pubblici
Introduzione al linguaggio Java 154
ESEMPIO
package pac
class a {...
class b {
private int i;
private void m( ) {…}
int j;
visibile
void n( ) {…}
public int k;
public p( ){…}
protected int i;
protected void m( ){…}
class
classddextends
extendsbb{...
{...
class e extends d {...
Introduzione al linguaggio Java 155
class c {...
PROGETTARE LA VISIBILITA’
Quando progettiamo una classe dobbiamo pensare
a due tipi di utenti:
• quelli che utilizzeranno la classe per realizzare
delle applicazioni
• quelli che estenderanno la classe per realizzare
sottoclassi
• I primi useranno i membri public; i secondi anche i
membri protected
• Le interfacce public e protected vanno progettate
con cura
Introduzione al linguaggio Java 156
DUE TIPI DI UTENTI
class a {
private int i;
private void m( ) {…}
int j;
void n( ) {…}
public int k;
public p( ){…}
protected int i;
protected void m( ){…}
ESTENDE
USA
package pac
interfaccia
interfaccia
Introduzione al linguaggio Java 157
PACKAGES: RIASSUNTO
I packages:
• permettono di creare gruppi di classi e interfacce
fra loro in relazione
• definiscono uno spazio di nomi locale per classi e
interfacce evitando conflitti con classi e interfacce di altri packages
• permettono di avere classi, interfacce e membri
(campi e metodi) non visibili all’esterno del
package
• possono essere organizzati gerarchicamente
Introduzione al linguaggio Java 158
UNITA’ DI COMPILAZIONE:
RIASSUNTO
MyClass.java
package Roberto.util;
import java.util.* ;
public class MyClass {
…
}
class MyOtherClass {
…
}
interface MyInterface {
…
}
/* opzionale */
/* opzionale */
/* opzionale */
/* opzionale */
Introduzione al linguaggio Java 159
STRUTTURA DI UN’APPLICAZIONE
Introduzione al linguaggio Java 160
STRUTTURA DI
UN’APPLICAZIONE
• Affinchè un sistema a oggetti “parta”, devo avere
una classe con un metodo statico e pubblico di
nome main
main
d
b
a
c
e
g
f
Introduzione al linguaggio Java 161
HALLO WORLD
Hello.java
class Hello {
public static void main (String args []) {
System.out.println("Hello World!");
}
}
obbligatorio in questa forma
Introduzione al linguaggio Java 162
SPIEGAZIONI
public static void main (String args [])
– void indica che main non ritorna nulla, il che è necessario per
superare il type-checking del compilatore
– args[] sono gli argomenti passati a main dalla shell quando si
digita: java Hello arg1 arg2 ... argn
– String dice che gli argomenti sono di classe String
– public rende il metodo main visibile alle altre classi - e al
comando java (interprete)
– static associa main alla classe Hello, e non alle sue istanze
System.out.println("HelloWorld!")
– invoca il metodo println dell’oggetto out della classe System,
che stampa la stringa sul file stdout
Introduzione al linguaggio Java 163
UNITA’ DI COMPILAZIONE
• Il sorgente di un’applicazione consiste di uno o più file
(“unità di compilazione”)
• Ogni file contiene una o più dichiarazioni di classi (o di
interfacce), di cui al più una dichiarata public
• Il nome del file deve essere uguale a quello della sua classe
public , con estensione .java:
file a.java
stesso nome
public class a {...
class b {...
class c {..
Introduzione al linguaggio Java 164
COMPILAZIONE ED ESECUZIONE
a.java
a.class
public class a {…
public main (..)
{….
java a args
javac a.java
<bytecode>
b.class
class b {…
…uso di c...
<bytecode>
La classe a deve
contenere un metodo
pubblico e statico di
nome main
c.class
<bytecode>
il compilatore crea
file di nome
classname.class
Introduzione al linguaggio Java 165
classe c, usata da
b, compilata in
precedenza
COMPILAZIONE ED ESECUZIONE
Verificare le caratteristiche
del sistema di programmazione
utilizzato
Introduzione al linguaggio Java 166
MULTITHREADING
Introduzione al linguaggio Java 167
CHE COS’E’ IL MULTITHREADING
• possibilità di realizzare più flussi di controllo
concorrenti (“threads”) nell’ambito di una stessa
applicazione
• possibilità di condividere dati fra i threads
• possibilità di controllare i threads e di sincronizzare i threads fra loro, attraverso opportune
primitive
Nota: la filosofia è ispirata ai monitor di C.A.R.
Hoare
Introduzione al linguaggio Java 168
MULTITASKING E MULTITHREADING
Multitasking
Multithreading
OS
OS
Task
1
Task
2
Task
1
Task
3
Task
2
Monitor
(interprete Java)
Memoria
condivisa
Memoria
condivisa
Thread
1
Memoria locale
Thread
2
Thread
3
Memoria
condivisa
Memoria locale
Memoria locale
Introduzione al linguaggio Java 169
RUN-TIME DATA AREA
Thread 1
Thread 2
Thread n
Program
Counter
Stack
….
Heap
oggetti condivisi fra i thread,
creati dinamicamente
e garbage collected
Method
Area
qui vengono caricati dal class loader i files
.class, contenenti la descrizione della
classe (campi, metodi, ecc.)
Introduzione al linguaggio Java 170
variabili locali,
ecc. dei metodi
LA CLASSE Thread
In Java, ogni thread è un oggetto:
• ogni singolo thread viene creato come una
istanza della classe java.lang.Thread
• ogni istanza di java.lang.Thread deve essere
associata a un metodo run() di qualche classe,
che contiene il codice che deve essere eseguito
dal thread
• la classe java.lang.Thread contiene tutti i metodi
per la gestione dei thread
• … e in particolare il metodo start(), per “lanciare”
il thread con il metodo run() “opportuno”
Introduzione al linguaggio Java 171
LA CLASSE Thread: SCHEMA
“lancia” il thread, rendendolo schedulabile. Esegue il metodo run() del Thread,
che a sua volta lancia il metodo run()
dell’oggetto passato come parametro
al costruttore Thread(), oppure (se
Thread non ha parametri) non fa nulla.
public class Thread implements Runnable
Runnable target;
….
public syncronized native void start() {
… run();
}
public void run() { if (target != null) { target.run(); } }
Thread (Runnable t) { target = t; …. }
}
public interface Runnable {
public abstract void run();
}
Introduzione al linguaggio Java 172
COME REALIZZARE UN THREAD
Ci sono due metodi per realizzare un thread:
Metodo 1:
implementando la interfaccia Runnable
Metodo 2:
estendendo la classe java.lang.Thread
e sovrascrivendo run()
Introduzione al linguaggio Java 173
METODO 1
public interface Runnable {
public abstract void run();
}
class Application implements Runnable {
public void run() { <body> }
}
...
Application a = new Application(); /* creo l’Application a il cui
metodo run() dovrà essere
eseguita in un thread */
Thread th = new Thread(a);
/* creo un thread e gli passo il
riferimento all’Application a */
th.start();
/* lancio il thread, eseguendo il
metodo a.run() */
Introduzione al linguaggio Java 174
ESEMPIO 1.1
public class drinks {
public static void main(String[] a) {
Coffee c = new Coffee(); Tea t = new Tea();
Thread th1 = new Thread(c) ; th1.start();
Thread th2 = new Thread(t) ; th2.start() ;
}
}
class Coffee implements Runnable {
public void run() {
while(true) { System.out.println(“I like coffee”);}
}
}
class Tea implements Runnable {
public void run() {
while(true) { System.out.println(“I like tea”);}
}
}
Introduzione al linguaggio Java 175
In questo esempio,
un main crea
e lancia i thread
ESEMPIO 1.2
public class drinks {
public static void main(String[] a) {
Coffee c = new Coffee(); Tea t = new Tea() ;
}
}
class Coffee implements Runnable {
Thread th;
public void run() {
while(true) { System.out.println(“I like coffee”);}
}
Coffee() { th = new Thread(this) ; th.start(); }
}
class Tea implements Runnable {
Thread th;
public void run() {
while(true) { System.out.println(“I like tea”);}
}
Tea() { th = new Thread(this) ; th.start() ; }
}
Introduzione al linguaggio Java 176
In questo esempio, ogni
oggetto crea e lancia
il proprio thread
METODO 2
class Thread implements Runnable {
public void start() { …
run();
}
public void run() { }
}
class MyThread extends Thread {
// eredita start()
public void run() { < body> }
}
MyThread p = new MyThread();
p.start();
Introduzione al linguaggio Java 177
sovrascrive
ESEMPIO 2.1
public class drinks {
public static void main(String[] a) {
Coffee th1=new Coffee(); th1.start();
Tea th2=new Tea() ; th2.start();
}
}
class Coffee extends Thread {
public void run() {
while(true) { System.out.println(“I like coffee”);}
}
}
class Tea extends Thread {
public void run() {
while(true) { System.out.println(“I like tea”);}
}
}
Introduzione al linguaggio Java 178
In questo esempio,
un main crea
e lancia i thread
ESEMPIO 2.2
public class drinks {
public static void main(String[] a) {
Coffee th1=new Coffee(); Tea=th2 new Tea() ;
}
}
class Coffee extends Thread {
public void run() {
while(true) { System.out.println(“I like coffee”);}
}
Coffee() { start(); }
}
class Tea extends Thread {
public void run() {
while(true) { System.out.println(“I like tea”);}
}
Tea() { start(); }
}
Introduzione al linguaggio Java 179
In questo esempio,
ogni thread si lancia
da solo
QUANDO UN thread TERMINA?
Un thread continua nella sua esecuzione, fino a
quando:
1. run() ritorna
2. viene eseguito il metodo stop() del thread
3. una eccezione causa l’uscita da run()
Introduzione al linguaggio Java 180
SCHEDULING
• lo scheduling è effettuato sulla base della priorità
dei thread
• la priorità può essere modificata mediante il
metodo setPriority
• a parità di priorità, lo scheduling è di tipo roundrobin
Introduzione al linguaggio Java 181
ALCUNI METODI DI Thread
public void start()
public void run()
public final void stop()
public final void suspend()
public final void resume()
public static void sleep(long n)
public final void setPriority(int newPriority)
public final int getPriority()
public static void yield()
public final native boolean isAlive()
...
Introduzione al linguaggio Java 182
lancia il thread
esegue il codice
distrugge il thread
sospende il thread
riattiva il thread
sospende il thread
per n msec
modifica la priorità
ottieni la priorità
rischedula
true se il thread è vivo
GLI STATI DI UN THREAD
Alive
yield()
new Thread()
New
thread
start()
suspend()
sleep()
wait()
Runnable
resume()
notify()
stop()
stop()
run() exit
Dead
Introduzione al linguaggio Java 183
stop()
Not
Runnable
IL PROBLEMA DELLA
MUTUA ESCLUSIONE
i=0
thread 1
thread 2
class Count {
int i = 0;
void incr() {
i+1 1
i = i + 1;
i -1 -1
}
i=1
void decr() {
i = -1
i = i - 1;
}
}
Il valore finale di i dipende dalla sequenza di esecuzione
Introduzione al linguaggio Java 184
METODI synchronized
Il modificatore synchronized prescrive che il
metodo a cui si applica sia eseguito da un solo
thread alla volta:
quando un thread esegue un metodo
synchronized, viene fatto un lock dell’oggetto
cui appartiene il metodo (o, per metodi static,
della classe)
quando il thread termina l’esecuzione del
metodo, viene fatta una unlock
prima di tale unlock, eventuali altri metodi
synchronized si pongono in attesa
Introduzione al linguaggio Java 185
ESEMPIO
thread 1
thread 2
lock
istanza di a
Introduzione al linguaggio Java 186
ESEMPIO
thread 1
thread 2
lock
istanza di a
istanza di a
Introduzione al linguaggio Java 187
ESEMPIO
thread 1
thread 2
lock
istanza di a
istanza di a
classe a
Introduzione al linguaggio Java 188
ESEMPIO
i=0
thread 1
thread 2
class Count {
int i = 0;
synchronized void incr() {
i+1 1
i = i + 1;
i=1
}
synchronized void decr() {
i -1 0
i = i - 1;
i=0
}
}
Il valore finale di i NON dipende dalla sequenza di esecuzione
Introduzione al linguaggio Java 189
BLOCCHI synchronized
• La keyword synchronized può essere usata anche
per proteggere blocchi arbitrari, e non solo
metodi
• in tal caso, occorre specificare l’oggetto di cui
acquisire il lock
Esempio:
synchronized ( myObject ) { <blocco> }
Introduzione al linguaggio Java 190
ESEMPIO
synchronized void MyMethod() {
…
}
è equivalente a:
void MyMethod() {
synchronized (this) {
…
}
}
Introduzione al linguaggio Java 191
ESEMPIO
import java.util.Vector;
public class MsgQueue {
Vector queue = new Vector();
public synchronized void send(Object obj) {
queue.addElement(obj);
}
public synchronized Object receive() {
if (queue.size() == 0) return null;
Object obj = queue.firstElement();
queue.removeElementAt(0);
return obj;
}
}
Introduzione al linguaggio Java 192
wait, notify
Sono metodi della classe Object:
public final void wait();
public final void wait(long millis);
/* rilascia il lock e si
pone in wait */
/* wait con timeout */
public final void notify();
/* rilascia il lock */
Introduzione al linguaggio Java 193
ESEMPIO
Schema Produttore-Consumatore
// Thread produttore: produce un dato
while (buffer_full) wait()
produce_data()
notify()
// Thread consumatore: consuma un dato
while (no_data) wait()
consume_the_data()
notify()
Introduzione al linguaggio Java 194