Perché paradigmi diversi?
Programmazione ad Oggetti
• Esistono numerose metodologie per lo sviluppo di
software, che dipendono dalle applicazioni (studiate
in Ingegneria del Software)
(BREVE CORSO INTRODUTTIVO)
• La scelta opportuna di un linguaggio di
programmazione può favorire l'adozione di una
metodologia e facilitare la soluzione di un problema
Matteo Baldoni
Dipartimento di Informatica - Universita` degli Studi di Torino
C.so Svizzera, 185 - I-10149 Torino (Italy)
e-mail: [email protected] - URL: http://www.di.unito.it/~baldoni
Programmazione ad Oggetti
Astrazione
Il ruolo dell'astrazione
• Astrazione: identificare le proprietà importanti di un
fenomeno, trascurando quelle irrilevanti
• Un programma realizza delle astrazioni. E'
essenziale concentrarsi solo sulle proprietà rilevanti
del fenomeno che si vuole modellare
• La mente umana può ricordare solo pochi concetti
contemporaneamente
• Un linguaggio di programmazione deve esser il più
possibile svincolato dalla macchina su cui viene
eseguito, ed essere vicino al problema da risolvere
• Un linguaggio di programmazione deve fornire
strumenti che facilitino lo sviluppo di astrazioni. In
particolare:
– astrazioni sulle operazioni (procedure)
– astrazioni sui dati (moduli, tipi di dati astratti,
classi)
• Lo sviluppo di un programma può procedere per
livelli di raffinamento successivo delle astrazioni
Programmazione ad Oggetti
2
Programmazione ad Oggetti
3
Paradigmi
4
Alcuni linguaggi
Prolog
• Linguaggi imperativi: basati sulle nozioni di variabili
e assegnamento - realizzano un astrazione
sull'architettura delle macchine
Lisp
Scheme
ML
Simula67
Miranda
Smalltalk
Java
C++
• Linguaggi funzionali e logici: basati su modelli
astratti di computazione derivati da teorie formali
(funzioni ricorsive, logica)
Cobol
C
Algol
Pascal
Ada
Modula2
Fortran
1960
Programmazione ad Oggetti
5
1970
1980
Programmazione ad Oggetti
1990
2000
6
1
Linguaggi ad oggetti
Programmazione ad oggetti
• I linguaggi di programmazione ad oggetti
consentono di applicare metodologie di sviluppo di
programmi "object oriented", ossia basate sugli
oggetti (dati) che il sistema software manipola.
• In molti casi l'organizzazione ad oggetti risulta la
più naturale perché rispecchia in modo diretto il
mondo che si vuole rappresentare:
– simulazione (automobili, semafori, aerei, …)
– software grafico (finestre, bottoni, menu, …)
• Questa metodologia si contrappone a quella più
tradizionale di sviluppare un programma secondo
un approccio funzionale (programmazione
strutturata).
Programmazione ad Oggetti
• Progetto object oriented di software: costruzione di
sistemi software come collezioni strutturate di
implementazioni di tipi di dati astratti (B. Meyer)
Programmazione ad Oggetti
7
I principali linguaggi ad
oggetti
8
Caratteristiche dei linguaggi
ad oggetti
Sette passi verso la felicità (secondo B. Meyer)
1. Struttura modulare basata sugli oggetti.
• Simula: progettato nel 1967 - capostipite dei
linguaggi ad oggetti
• Smalltalk: linguaggio ad oggetti "puro" - linguaggio
"dinamico” non c'è controllo statico dei tipi
3. Gestione automatica della memoria.
(garbage collection)
• C++: linguaggio "ibrido" - garantisce la
compatibilità con il C
• Java: il più recente.
Programmazione ad Oggetti
2. Gli oggetti sono implementazioni di tipi di dati
astratti.
4. Classi.
Ogni tipo non semplice è un modulo, e ogni
modulo ad alto livello è un tipo.
Programmazione ad Oggetti
9
Caratteristiche dei linguaggi
ad oggetti
10
Java
• Le caratteristiche principali di Java
5. Ereditarietà.
Una classe può essere definita come
estensione o restrizione di un'altra.
• Object oriented:
– progettato per essere un linguaggio ad oggetti, anche se
meno puro di Smalltalk
6. Polimorfismo e binding dinamico.
Possibilità di fare riferimento ad oggetti di
più di una classe.
• Robusto
– non ci sono puntatori
Le operazioni possono avere realizzazioni
diverse in classi diverse.
– garbage collection
• Distribuito
7. Ereditarietà multipla.
Possibilità di ereditare da più di una classe.
Programmazione ad Oggetti
– costrutti per la concorrenza
11
Programmazione ad Oggetti
12
2
Sommario della
presentazione
Java
• Indipendente dall'architettura
•
•
•
•
•
•
Ogni oggetto ha un’interfaccia
Ogni oggetto ha un tipo
Riuso del software: composizione
Riuso del software: ereditarieta`
Polimorfismo e binding dinamico
Gli oggetti prima di tutto: GUI, Event-driven
programming e l’architettura modello-vistacontrollore
• Java: dove e come
• Java oltre: Applet, Servlet , RMI, ...
– il compilatore genera codice intermedio (bytecode) che
viene interpretato
• Applicazioni su internet
– applet
– sicurezza
• Ambiente ricco di tipi di dati predefiniti
– grafica
– programmazione su internet
– accesso a database
Programmazione ad Oggetti
13
Programmazione ad Oggetti
14
Oggetti
Un oggetto rappresenta un dato, ed è costituito da
Ogni oggetto
ha
un’interfaccia
e ogni oggetto
ha un tipo
Programmazione ad Oggetti
• stato: collezione di variabili
• comportamento: collezione di operazioni (metodi)
Esempio - contatore
STATO
int c;
METODI
void iniz(int i)
void incr()
void decr()
int val()
15
Incapsulamento
inizializza il contatore a i
incrementa il contatore di 1
decrementa il contatore di 1
restituisce il valore del
contatore
Programmazione ad Oggetti
16
Contatore
• I dati e le procedure che li manipolano sono
raggruppati in un’unica entità, l’oggetto.
• Il mondo esterno ha accesso ai dati solo tramite un
insieme di operazioni (metodi) che costituiscono
l’interfaccia dell’oggetto. I dettagli dell’implementazione sono nascosti (INFORMATION HIDING)
void iniz(int i)
void incr()
void decr()
int val()
int c;
void iniz(int i) {c=1;}
void incr() {++c;}
void decr() {--c;}
int val() {return c;}
INTERFACCIA
IMPLEMENTAZIONE
CONTATORE
• Un oggetto realizza una ASTRAZIONE DEI DATI
Programmazione ad Oggetti
17
Programmazione ad Oggetti
18
3
Invio di Messaggi
Invio di Messaggi
• Un programma è costituito da un insieme di
oggetti.
• Gli oggetti sono dinamici - creati e distrutti durante
l'esecuzione del programma.
• Un oggetto A, per agire su un altro oggetto B, invia
un messaggio a B chiedendogli di eseguire uno dei
metodi della sua interfaccia.
finestra
display
contatore
invia valore di c
0
c
esegui incr()
Es.: esegui il
metodo m1
bottone 3
bottone 1
bottone 2
• Lo scambio di messaggi è l'unico modo di
comunicare tra oggetti
Programmazione ad Oggetti
Programmazione ad Oggetti
19
Invio di Messaggi
Invio di Messaggi
• invio di messaggio = invocazione di un metodo
• In Java, e altri linguaggi, si usa la notazione con il
punto: oggetto.metodo(…)
cont1
3
• In un linguaggio tradizionale, per eseguire una
operazione su un dato, dovremmo passare il dato
come parametro:
– incr(cont1) o iniz(cont1, 3)
int x,y;
cont1.incr();
cont2.decr();
x = cont1.val();
y = cont2.val();
• Nella programmazione ad oggetti, invece, l'oggetto
su cui si esegue una operazione non viene passato
come parametro, perché figura già come
destinatario del messaggio (può essere considerato
come un parametro implicito)
– cont1.incr() o cont1.iniz(3)
cont2
10
20
x ha valore 4 e y ha valore 9
Programmazione ad Oggetti
Programmazione ad Oggetti
21
Classi
22
Classi (Java)
• I più diffusi linguaggi ad oggetti sono basati sul
concetto di classe come insieme di oggetti con
struttura e comportamento simili
• La classe definisce un tipo
• Istanza di una classe = oggetto della classe
• Una classe realizza l'implementazione di un tipo di
dato astratto.
• In Java:
class Contatore {
int c;
void iniz(int i) {c = i;}
void incr() {++c;}
void decr() {--c;}
int val() {return c;}
}
Istanze
cont1
cont2
3
Programmazione ad Oggetti
10
23
Programmazione ad Oggetti
24
4
Classi (Java)
Variabili private (Java)
• Per realizzare information hiding si usano le parole
riservate
– public - interfaccia
– private - implementazione
• Per il momento trascuriamo questo aspetto
class Contatore {
private int c;
public void iniz(int i) {c = i;}
public void incr() {++c;}
public void decr() {--c;}
public int val() {return c;}
}
Programmazione ad Oggetti
class Contatore {
private int c;
public void iniz(int i) {c = i;}
public void incr() {++c;}
public void decr() {--c;}
public int val() {return c;}
}
• Si noti che, se la variabile c fosse public, il metodo
val sarebbe inutile: per conoscere il valore di un
contatore cont basterebbe usare cont.c
• Tuttavia è buna norma di programmazione
impedire l’accesso diretto alle variabili di un
oggetto, dichiarandole private.
Programmazione ad Oggetti
25
Tipi
Tipi di dato primitivi (Java)
• Java è un linguaggio tipato: tutte le variabili hanno
un tipo.
• Il tipo di una variabile deve sempre essere
dichiarato e può essere:
– una classe
– un tipo primitivo
Contatore cont;
int x,y;
char ch;
Programmazione ad Oggetti
27
Come si crea un’istanza
• Java fornisce diversi tipi semplici primitivi.
• A differenza di altri linguaggi, la dimensione dei tipi
numerici è fissata per consentire la portabilità dei
programmi:
–
–
–
–
–
–
–
–
byte
short
int
long
float
double
char
boolean
8
16
32
64
32
64
16
bit
bit
bit
bit
bit
bit
bit (Unicode)
Programmazione ad Oggetti
28
Gestione della memoria
• new Contatore()
• Nella maggior parte dei linguaggi di
programmazione le attivazioni di procedure sono
gestite con uno stack (pila)
• Crea un nuovo oggetto di tipo Contatore e ne
restituisce il puntatore (handle)
• Quando una procedura è chiamata, si inserisce un
record di attivazione in cima alla pila, e lo si toglie
quando l'esecuzione della procedura termina
• Tutti gli oggetti sono allocati dinamicamente
(quando si esegue la new) e sono manipolati
attraverso una handle (puntatore) (assegnamento,
passaggio di parametri)
Programmazione ad Oggetti
26
29
• Un record di attivazione contiene le informazioni sul
controllo (indirizzo di ritorno) ed i dati locali
• Possibilità di chiamate ricorsive di procedure
Programmazione ad Oggetti
30
5
Gestione della memoria
Recupero della memoria
STATICA
dati globali
• Garbage collection (Scheme, Prolog, Java)
STACK
record di attivaz.
dati locali
Codice
• Il programmatore può solo allocare dati dinamici
• Una procedura di sistema, il garbage collector, si
preoccupa di recuperare tutte le aree di memoria
nello heap non più raggiungibili in modo da poterle
riutilizzare
• Altri linguaggi come Pascal o C lasciano al
programmatore la responsabilità di recuperare la
memoria, con possibilità di commettere errori
HEAP
dati dinamici
Programmazione ad Oggetti
31
Allocazione dinamica
Contatore cont1, cont2;
Programmazione ad Oggetti
32
Allocazione dinamica
Contatore cont1, cont2;
cont1 = new Contatore();
cont2 = new Contatore();
cont1.iniz(3);
cont2.iniz(10);
cont1
cont2
cont1
cont2
3
10
HEAP
Programmazione ad Oggetti
33
Allocazione dinamica
Contatore cont1, cont2;
cont1 = new Contatore();
cont2 = new Contatore();
cont1.iniz(3);
cont2.iniz(10);
cont2 = cont1;
Programmazione ad Oggetti
34
Puntatori (Java)
• In Java non esistono puntatori espliciti
cont1
cont2
Contatore cont;
3
• Fino a quando non si esegue una new, la variabile
cont non è associata a nessun oggetto
• Viceversa in C++ si può dichiarare
Questo oggetto non è più accessibile.
Può essere recuperato dal garbage
collector.
sia Contatore cont1; sia Contatore *cont2;
10
• cont1 è associato ad un contatore creato
"staticamente”, cont2 è associato ad un contatore
creato dinamicamente (vedi Java)
HEAP
Programmazione ad Oggetti
35
Programmazione ad Oggetti
36
6
Come si inizializza un oggetto
• Si può chiamare esplicitamente un metodo di
inizializzazione:
Contatore cont1;
cont1 = new Contatore();
cont1.iniz(3);
37
Overloading di metodi
(e costruttori)
Contatore cont;
cont = new Contatore(3);
int x = 10;
cont
x
3
• Esistono classi wrapper che
trasformano tipi semplici in
oggetti
39
THIS
HEAP
Programmazione ad Oggetti
40
Programmi in Java
• Come può un oggetto mandare un messaggio a se
stesso, ossia invocare un proprio metodo?
• Con la parola chiave this
• Un programma in Java è una collezione di classi
• Una di queste deve contenere un metodo main
• L'esecuzione inizia dal main
• Il metodo main deve essere statico, perché
altrimenti bisognerebbe creare un oggetto della
classe Esempio prima di poterlo eseguire
In alcuni casi this
è indispensabile
class Esempio {
public static void main(String arg[]) {
System.out.println("questo è un esempio");
}
}
si può anche scrivere solo p()
this viene aggiunto dal compilatore
Programmazione ad Oggetti
38
• I tipi semplici, come ad es.
gli interi, non vengono
allocati dinamicamente nello
heap, a differenza di altri
linguaggi "puri" come
Smalltalk
class Contatore {
int c;
Contatore() {c = 0;}
Contatore(int i) {c = i;}
void incr() {++c;}
void incr(int n) {c += n;}
void decr() {--c;}
int val() {return c;}
}
class A {
...
void p() {...}
void m() { ... this.p(); ...}
}
Programmazione ad Oggetti
I tipi semplici non sono
oggetti (Java)
• Overloading: metodi diversi possono avere lo
stesso nome.
• I metodi "overloaded" si distinguono uno dall'altro
in base alla lista dei tipi degli argomenti.
Programmazione ad Oggetti
costruttore
• L'oggetto viene inizializzato al momento della
creazione, invocando automaticamente il
costruttore.
• L’istruzione Contatore cont1 = new Contatore(3); crea
un contatore e lo inizializza a 3.
• L'inizializzazione di un oggetto è una operazione
molto importante.
• Java (e C++) forniscono la nozione di costruttore,
che consente di inizializzare automaticamente un
oggetto al momento della creazione.
Programmazione ad Oggetti
Costruttori
class Contatore {
int c;
Contatore(int i) {c = i;}
void incr() {++c;}
void decr() {--c;}
int val() {return c;}
}
41
Programmazione ad Oggetti
42
7
Interpretazione
Compilazione
Interprete
Sparc/Solaris
binario
Compilatore
Sparc/Solaris
Sparc/Solaris
Codice Sorgente
Sparc/Solaris
Codice Sorgente
Interprete
MacOS
binario
Apple
Apple
Compilatore
Intel/GNU-Linux
Interprete
Intel/GNU-Linux
• Interprete (JavaScript, Scheme, Prolog):
Interazione. Più facile modificare un
programma durante l'esecuzione
Intel/GNU-Linux
Programmazione ad Oggetti
43
binario
• Compilazione (Pascal, C, Ada, C++):
Efficienza di esecuzione. Il codice
generato dal compilatore può essere
ottimizzato, perché la compilazione è
fatta una sola volta
Intel/GNU-Linux
Programmazione ad Oggetti
44
Compilazione di un
programma in Java
Soluzione Mista: Java
• Soluzione mista (Java): Portabilità.
Per eseguire un programma su
macchine diverse è sufficiente
implementare l'interprete del
linguaggio intermedio, e non tutto il
compilatore
bytecode
Compilatore
MacOS
Interprete
Java/Solaris
Sparc/Solaris
Interprete
Java/MacOS
Apple
• Si crea un file <nome_file>.java contenente una o
più classi C1, C2, … e lo si compila.
> javac <nome_file>.java
Codice Java
Compilatore
Java
• Il compilatore crea un file .class in codice
intermedio (bytecode) per ogni classe contenuta
nel file .java:
Interprete
Java/GNU-Linux
Interprete
Java/PalmOS
Intel/GNU-Linux
C1.class, C2.class, ...
Palm VII
Programmazione ad Oggetti
45
Esecuzione di un
programma in Java
46
Un programma completo
• Si chiama l'interprete su una classe che contiene il
main (Es. C1)
> java C1
class Contatore {
int c;
Contatore(int n) {c=n;}
void incr() {++c;}
void decr() {--c;}
int val() {return c;}
}
> javac <nome_file>.java
> java UsaCont
class UsaCont {
public static void main(String arg[]) {
Contatore cont = new Contatore(5);
cont.incr();
System.out.println("valore =" + cont.val());
}
}
• L'interprete alloca questa classe e comincia ad
eseguire il main.
Programmazione ad Oggetti
Programmazione ad Oggetti
47
Programmazione ad Oggetti
48
8
Compilazione in Java
• Una unità di compilazione è un file .java che
contiene delle definizioni di classi.
• Al massimo una di queste classi può essere public:
in questo caso deve avere lo stesso nome del file
(senza .java).
• Il compilatore produce un file .class per ogni classe
nel file.
• L'interprete ha la responsabilità di caricare e
interpretare questi file.
Programmazione ad Oggetti
49
Ereditarietà
Riuso del
software:
Ereditarieta`,
Composizione,
Polimorfismo
e Binding
Dinamico
Programmazione ad Oggetti
50
Ereditarietà
• Meccanismo per lo sviluppo incrementale di
programmi
• Consente di estendere classi preesistenti
aggiungendo o modificando componenti (variabili o
metodi)
class Finestra {
Rettangolo r; ....
void disegnaCornice() {...}
void disegnaContenuto() {...}
}
• Data la classe di sopra vogliamo estendere la finestra
aggiungendo un titolo
class FinestraConTitolo extends Finestra {
String titolo;
void disegnaTitolo() {...}
}
Programmazione ad Oggetti
51
Sottoclassi
Programmazione ad Oggetti
52
Ereditarietà
• Gli oggetti della classe Finestra sono costituiti da
• FinestraConTitolo è una
sottoclasse di Finestra.
• Una sottoclasse eredita
tutte le variabili ed i
metodi della
sopraclasse.
Programmazione ad Oggetti
53
variabili
Rettangolo r;
metodi
void disegnaCornice() {...}
void disegnaContenuto() {...}
• Gli oggetti della classe FinestraConTitolo sono
costituiti da
variabili
Rettangolo r;
String titolo;
metodi
void disegnaCornice() {...}
void disegnaContenuto() {...}
void disegnaTitolo() {...}
Programmazione ad Oggetti
54
9
Extends (Java)
Extends (Java)
• E` la parola chiave per definire una gerarchia di
classi
• Superclasse, classe base, classe padre
• Sottoclasse, classe derivata, classe figlia
ClassePadre
ClasseFigliaUno
Ereditarieta`
class ClassePadre {
[…]
}
ClasseFigliaDue
class ClasseFigliaUno extends ClassePadre {
[…]
}
class ClasseFigliaDue extends ClassePadre {
[…]
}
Programmazione ad Oggetti
A
A
x∈B⇒x∈A
class B extends A
B
B
55
Controllo statico dei tipi
Programmazione ad Oggetti
56
Controllo statico dei tipi
Finestra f;
FinestraConTitolo ft;
...
ft.disegnaCornice();
f.disegnaCornice();
ft.disegnaTitolo();
f.disegnaTitolo();
• Java, come molti altri linguaggi, effettua un
controllo dei tipi (type checking) statico.
• Statico: fatto dal compilatore prima di iniziare
l'esecuzione del programma.
• Dinamico: fatto dall'interprete durante l'esecuzione
(a runtime)
• Il type checking statico garantisce che non ci
saranno errori durante l'esecuzione.
Programmazione ad Oggetti
• Le sottoclasse hanno le funzionalita` delle proprie
sopraclassi piu` altre specifiche
• Specializzazione
• Un elemento di una sottoclasse e` anche un
elemento di una sua sopraclasse
corretto
errore di compilazione
f è una finestra e non ha il
metodo disegnaTitolo
• Type checking statico: il compilatore controlla che
per una variabile si chiami un metodo definito per
la classe di quella variabile.
57
Tassonomie
Programmazione ad Oggetti
58
Sottotipi
• Spesso l'ereditarietà è utilizzata per rappresentare
tassonomie (classificazioni)
• Una sottoclasse può essere vista come l'implementazione di
un sottotipo.
• L'ereditarietà realizza una relazione is-a (è un).
• Un rettangolo è un poligono.
• Un rettangolo ha tutte le operazioni di poligono
(eventualmente ridefinite) più altre operazioni specifiche.
Programmazione ad Oggetti
59
Programmazione ad Oggetti
60
10
Ereditarietà singola
Ereditarietà multipla
• Ogni sottoclasse ha una
sola sopraclasse.
• Struttura ad albero.
• In Java la classe Object
è la radice della
gerarchia.
ApparecchioElettrico
tensione
potenza
• Qualunque oggetto è
un Object.
• I tipi primitivi non sono
Object.
Programmazione ad Oggetti
Televisore
pollici
• In Java non è permessa.
• Dà maggiore espressività ma crea problemi di conflitti e
duplicazioni.
Programmazione ad Oggetti
61
Polimorfismo
A
d
b
a
a
Esempio:
• D sottoclasse di B e di A
• un oggetto D è un B ed è un A
• un oggetto di tipo (classe) D è
anche un oggetto di tipo
(classe) B e anche un oggetto
di tipo (classe) A
a; B b; D d;
= new D();
= new D();
= new D();
= b;
questi
assegnamenti
sono tutti legali
perché un
oggetto di tipo D
ha anche tipo B
eA
Programmazione ad Oggetti
63
Polimorfismo
64
Upcasting
A a; B b; D d;
d = new D();
• L'assegnamento x = espr è legale per il
compilatore se:
– A uguale a B
– B sottoclasse (sottotipo) di A
dove A è il tipo di x e B è il tipo di espr
b = d;
d viene visto come se fosse un oggetto di tipo B
a = d;
d viene visto come se fosse un oggetto di tipo A
• Upcasting: ci si muove da un tipo specifico ad uno
più generico (da un tipo ad un suo “sopratipo”).
• Analogamente se x è un parametro formale di un
metodo e espr è il parametro attuale (della
chiamata)
• Controllo statico.
Programmazione ad Oggetti
62
Polimorfismo
• POLIMORFISMO: proprietà di
un oggetto di avere più di un
tipo, in accordo alla relazione di
ereditarietà.
Programmazione ad Oggetti
Articolo
codice
prezzo
65
• L’upcasting è sicuro per il type checking: dato che
una sottoclasse eredita tutti i metodi delle sue
sopraclassi, ogni messaggio che può essere inviato
ad una sopraclasse può anche essere inviato alla
sottoclasse senza il rischio di errori durante
l'esecuzione.
Programmazione ad Oggetti
66
11
Upcasting
Poligono p;
Rettangolo r;
...
p.disegna();
r.disegna();
p.perimetro();
r.perimetro();
Upcasting
Poligono p;
Rettangolo r;
...
r.diagonale(); corretto
p.diagonale();
corretto
per il
compilatore
Programmazione ad Oggetti
errore di
compilazione
p è di tipo
Poligono e non ha
il metodo
diagonale
67
Upcasting
Poligono p;
Rettangolo r;
...
p = r;
r.diagonale();
p.diagonale();
Programmazione ad Oggetti
68
Upcasting
p
Poligono p;
Rettangolo r;
p = r;
r.diagonale(); corretto
r
Rettangolo
Il compilatore dà errore ma, se si
facesse il controllo a runtime,
p.diagonale() sarebbe corretto
perché p è legata ad un rettangolo
(che possiede il metodo diagonale).
p.diagonale();
se si facesse il controllo a runtime,
sarebbe corretto perché p è legata ad
un rettangolo (che possiede il
metodo diagonale).
Visto da p, il rettangolo è un
poligono.
Programmazione ad Oggetti
69
Overriding
Programmazione ad Oggetti
70
Cella (1)
• Una sottoclasse può anche ridefinire (OVERRIDING) un
metodo della sopraclasse.
class Cella {
int contenuto=0;
int get() {return contenuto;}
void set(int n) {contenuto=n;}
}
class Finestra {
Rettangolo r; ....
void disegnaCornice() {...}
void disegnaContenuto() {...}
}
class CellaConMemoria extends Cella {
int backup=0;
void set(int n) {backup=contenuto;
contenuto=n;}
void restore() {contenuto=backup;}
}
class FinestraConTitolo extends Finestra {
String titolo;
void disegnaCornice() { … disegna la cornice
con il titolo …}
}
Programmazione ad Oggetti
errore di
compilazione
p è di tipo
Poligono e non ha
il metodo
diagonale
71
Programmazione ad Oggetti
72
12
Ereditarietà da Object (Java)
Complex c = new Complex(1.5, 2.4);
System.out.println(c);
class Complex {
double re,im;
...
}
Si può ridefinite toString
c viene convertito in stringa con
il metodo toString definito in
Object.
Si ottiene: Complex@.........
Con la stampa si ottiene:
1.5 + i 2.4
• Spesso un metodo di una sottoclasse definito per
overriding non ridefinisce completamente il metodo
con lo stesso nome della sua sopraclasse, ma lo
estende.
• Ad esempio, il metodo disegnaCornice della
FinestraConTitolo estende il metodo disegnaCornice
della Finestra, con del codice specifico per
disegnare il titolo.
class Complex {
...
String toString() {
return(re + " + i " + im);
}
}
Programmazione ad Oggetti
Come estendere un metodo
• Per evitare di duplicare il codice, si può far
riferimento ad un metodo della sopraclasse con lo
stesso nome mediante la notazione super.
73
super
Programmazione ad Oggetti
74
Cella (2)
Per ridefinire un metodo in modo incrementale:
class Cella {
int contenuto=0;
int get() {return contenuto;}
void set(int n) {contenuto=n;}
}
class FinestraConTitolo extends Finestra {
String titolo;
void disegnaCornice() {
super.disegnaCornice();
... nuovo codice ...
}
}
class CellaConMemoria extends Cella {
int backup=0;
void set(int n) {backup=contenuto;
super.set(n);}
void restore() {contenuto=backup;}
}
super.disegnaCornice() chiama il metodo
disegnaCornice della sopraclasse (che altrimenti non
sarebbe visibile).
Programmazione ad Oggetti
75
Upcasting
76
Binding dinamico
Poligono p;
Rettangolo r;
...
p = r;
p.disegna();
• Un oggetto decide quale metodo applicare a se
stesso in base alla propria posizione nella gerarchia
dell’ereditarieta`
p.perimetro();
• Binding dinamico: decidere a tempo di esecuzione
quale metodo applicare
corretto per il
compilatore, ma
quale metodo si
esegue?
Quello di Poligono o
quello di Rettangolo?
Programmazione ad Oggetti
Programmazione ad Oggetti
• Binding statico: decidere a tempo di compilazione
quale funzione applicare (Pascal, C, …)
Java adotta il binding dinamico
77
Programmazione ad Oggetti
78
13
Binding dinamico
Binding dinamico
p.perimetro();
• In questo contesto:
Si esegue il metodo perimetro dell'oggetto a cui p fa
riferimento in quel momento.
• Binding: legame fra il nome di un metodo in una
invocazione e (codice del) metodo.
Poligono p = new Poligono();
Rettangolo r = new Rettangolo();
• obj.m(): quale metodo m viene eseguito?
p.perimetro();
• Nei linguaggi tradizionali le chiamate di procedura
vengono risolte dal compilatore.
si esegue il metodo
perimetro di Poligono
p = r;
p.perimetro();
• Nei linguaggi ad oggetti (tranne il C++) le
chiamate di metodi sono risolte dinamicamente.
si esegue il metodo
perimetro di Rettangolo
Programmazione ad Oggetti
• BINDING DINAMICO: la forma di un oggetto
determina dinamicamente quale versione di un
metodo applicare.
79
Binding dinamico
void rinfresca() {
this.disegnaCornice();
this.disegnaContenuto();
}
this (che può anche essere omesso) si
riferisce sempre all’oggetto corrente.
FinestraConTitolo ft;
...
ft.rinfresca();
class FinestraConTitolo extends Finestra {
String titolo;
void disegnaCornice() { … disegna la cornice
con il titolo …}
}
chiama il metodo disegnaCornice di
FinestraConTitolo
81
Programmazione ad Oggetti
82
Private, public,
protected, o … (Java)
Overrinding
Ricerca di un metodo per un oggetto:
• la sottoclasse verifica se possiede o meno un
metodo con tale nome e con gli stessi parametri
(stessa signature), se si`, lo usa
• se no, la classe padre cerca per la classe figlia tale
metodo tra quelli in essa definiti (e cosi` via nella
gerarchia)
• Un metodo definito in una sottoclasse e avente la
stessa signature di un metodo di una delle classi
antenate nasconde il metodo di quest’ultima alla
sottoclasse
Programmazione ad Oggetti
80
Binding dinamico
class Finestra {
Rettangolo r; ....
void disegnaCornice() {...}
void disegnaContenuto() {...}
void rinfresca() {
this.disegnaCornice();
this.disegnaContenuto();
}
}
Programmazione ad Oggetti
Programmazione ad Oggetti
Modificatori d’accesso di Java che controllano la
visibilita` di campi di istanze o metodi:
• nessuna specifica: visibile al package
• private: visibile alla sola classe di appartenenza
• public: visibile ovunque
• protected: visibile al package e a tutte le
sottoclassi (una classe potrebbe estenderne
un’altra non appartenente allo spesso pacchetto)
Cosa scegliere?
83
Programmazione ad Oggetti
84
14
Private, … (Java)
Riuso del software
• La programmazione ad oggetti consente di
utilizzare classi già esistenti per produrre nuovo
software:
• Per i metodi:
– public per l’interfaccia
– private per i metodi di “servizio”
• Uso.
• Per i campi:
– private e` sempre la soluzione consigliata, se e`
necessario accederne al valore allora si definisce
un metodo di accesso
– protected se si vuole renderli accessibili alle
sottoclassi
– public, nulla ...
Programmazione ad Oggetti
– Si definiscono nuove classi i cui oggetti sono
composti di oggetti di classi già esistenti.
• Ereditarietà.
– Favorisce lo sviluppo incrementale, estendendo
classi già esistenti.
Programmazione ad Oggetti
85
Composizione
class Automobile {
int lunghezza;
Motore motore;
Ruota[] ruote;
...
}
– Un oggetto comunica con oggetti di altre classi
• Composizione.
Ereditarietà vs composizione
class Ruota {
double pressione;
int diametro;
...
}
AppElettr
Articolo
Televisore
class Motore {
int cilindrata;
...
}
Automobile
Motore
Automobile miaAuto = new Automobile();
...
miaAuto.motore.cilindrata
miaAuto.ruote[1].pressione
Programmazione ad Oggetti
86
Ruote
Carrozzeria
87
Programmare con
l'ereditarietà
Televisore è un
apparecchio elettrico e è
un articolo.
La sottoclasse eredita il
comportamento di altre classi.
L'automobile ha un motore,
una carrozzeria, …
L'automobile non ha il
comportamento del motore,
...
Programmazione ad Oggetti
88
Programmare con
l'ereditarietà
• Si consideri una figura
composta di diverse forme void disegna(figura f) {
geometriche (linee,
for ogni forma S in f
rettangoli, cerchi, …).
switch(S.genere)
• Nella programmazione
tradizionale, una procedura
per disegnare la figura
dovrebbe considerare tutti i
casi.
…
• Se si aggiunge la forma
}
TRIANGOLO occorre
modificare la procedura
disegna.
case LINEA:
disegnaLinea()
case RETTANGOLO:
disegnaRettangolo()
case CERCHIO:
disegnaCerchio()
Programmazione ad Oggetti
89
class Figura {
Forma[] s; //una figura è inplementata
//come un array di Forme
void disegnaFigura() {
for (int i=0; i<s.length; i++)
s[i].disegna();
}
...
Programmazione ad Oggetti
90
15
Programmare con
l'ereditarietà
Classi astratte
• Se si aggiunge la forma Triangolo, è sufficiente
definire una nuova sottoclasse di Forma con il
metodo disegna:
class Triangolo extends Forma {
...
void disegna(){...}
}
• In un programma non ci si aspetta di chiamare il
metodo disegna della classe Forma, né di usare
oggetti di questa classe.
• La classe Figura non viene modificata.
• Il binding dinamico fa sì che, se la figura contiene
un triangolo, venga chiamato il metodo per
disegnare un triangolo.
Programmazione ad Oggetti
• La classe Forma serve solo per avere una
interfaccia comune per le varie forme specifiche.
Programmazione ad Oggetti
91
Classi astratte
92
Es.: Poligoni
Alcuni metodi (dichiarati abstract) non sono implementati
• perimetro, area
sono piu` volte
ridefinite nella
gerarchia di classe
abstract class Forma {
abstract void disegna(); Non c'è la implementa}
zione del metodo
class Linea extends Forma {
void disegna() { ......}
}
....
Forma f = new Forma();
Errore di compilazione.
Non si possono creare oggetti di una classe astratta.
Forma f = new Linea();
f.disegna();
Programmazione ad Oggetti
Programmazione ad Oggetti
93
Es.: Prisma
94
Interfacce
• Una classe astratta pura costituisce una interfaccia.
• I metodi volume,
superficieLaterale
e SuperficieTotale
sono polimorfi
• In Java può essere definita anche come interface.
interface Forma {
void disegna();
}
class Linea implements Forma {
void disegna() { ......}
}
...
Forma f = new Linea();
f.disegna();
Programmazione ad Oggetti
95
Programmazione ad Oggetti
96
16
Interfacce vs. classi
astratte
Interfacce multiple
interface A {
interface B {
void metodoA();
void metodoB();
}
}
• Le classi astratte possono essere miste, ossia
possono contenere anche metodi non astratti.
• Con l'ereditarietà singola di Java, una classe può
essere sottoclasse solo di una classe astratta.
class C implements A,B {
void metodoA() {System.out.println("sono A");}
void metodoB() {System.out.println("sono B");}
• Le interfacce invece non sono soggette al vincolo
della struttura gerarchica ad albero.
public static void main(String[] args) {
A a = new C();//l’oggetto è visto come un A
B b = new C();//l’oggetto è visto come un B
a.metodoA();
b.metodoB();
a.metodoB(); //errore: A non ha il metodB
}
• Una classe può implementare più di una interfaccia
(qualche analogia con ereditarietà multipla).
Programmazione ad Oggetti
97
}
Programmazione ad Oggetti
Classi generiche
• La proprietà che tutte le
classi sono discendenti di
Object consente di definire
strutture dati che possono
contenere oggetti di
qualunque tipo.
Downcasting
class Pila {
...
void push(Object x) {...};
Object pop() {...};
}
• Non si può specificare il tipo
Pila s; Linea l; Rettangolo r;
degli elementi della pila:
...
possono essere oggetti
s.push(l); s.push(r);
qualunque.
class Pila {
...
void push(Object x) {...};
Object pop() {...};
}
99
Downcasting
Errore di compilazione.
pop restituisce un Object, che è
più generale di Rettangolo
Programmazione ad Oggetti
100
Downcasting
class Pila {
...
void push(Object x) {...};
Object pop() {...};
}
• Downcasting: ci si muove da un tipo più generale
ad uno più specifico (da un tipo ad un sottotipo)
• Se A è un sottotipo di B e se espr ha tipo B,
(A) espr ha tipo A
...
Pila s; Rettangolo r;
...
s.push(new Rettangolo());
• L’assegnamento
A a = (A) espr è corretto per il compilatore
• (A) espr può dare errore a run time, se l’oggetto
ottenuto valutando espr non ha tipo A.
r = (Rettangolo) s.pop();
Non e` un cast alla “C” !
Programmazione ad Oggetti
Supponiamo di sapere che
sulla pila vengono messi
solo rettangoli. Come
possiamo utilizzare gli
oggetti estratti dalla pila?
Pila s; Rettangolo r;
...
s.push(new Rettangolo());
r = s.pop();
Programmazione ad Oggetti
98
101
Accettato dal compilatore.
Può dare errore a run time.
Controllo a run-time.
Quando si esegue questa
istruzione
si controlla che l'oggetto
restituito
da pop sia veramente un
rettangolo.
Programmazione ad Oggetti
102
17
Graphical User Interface
Gli oggetti
prima di
tutto: GUI,
Event-driven
programming
e
l’architettu
ra MVC
• Un programma che fa uso di
di strumenti grafici come
bottoni, menu`, disegni,
finestre, ecc. per facilitare le
operazioni di input e
visualizzazione dell’output
• Un GUI per il contatore: una
finestra che permetta di
controllare l’invio dei
messaggi di incremento,
decremento, inizializzazione
di un contatore, nonche` la
visualizzazione del suo
valore corrente
Programmazione ad Oggetti
103
– un bottone per
abbandonare l’interfaccia
chiude la
finestra
decrementa il
contatore di 1
chiude la
finestra
incrementa il
contatore di 1
Programmazione ad Oggetti
105
L’architettura
Model View Controller
Un programma si compone di
• Modello (Model): modella e
calcola il problema che
desideriamo risolvere
• Vista (View): rappresenta
una “fotografia” dello stato
interno del modello spesso
per facilitarne la sua
lettura/interpretazione
all’utente umano
• Controllore (Controller):
controlla il flusso di dati nel
programma, dalla vista al
modello e quindi
nuovamenta alla vista
• Ha origine negli applicativi
sviluppati in Smalltalk
• E` stato utilizzato in Java
per lo sviluppo delle
componenti AWT/Swing
Programmazione ad Oggetti
106
Architettura MVC: vantaggi
http://www.cis.ksu.edu/~schmidt/CIS200
• L’utente agisce sulla vista
di un programma agendo
su una delle sue
componenti di controllo
(es. bottone)
• Il controllore e` avvertito
di tale evento ed esamina
la vista per rilevarne le
informazioni aggiuntive
• Il controllore invia tali
richiede alla vista di visualizzainformazioni al modello che
re il risultato della computazione
effettua la computazione
• La vista interroga il modello sul
richiesta e aggiorna il
suo nuovo stato interno e
proprio stato interno
visulizza l’informazione
• Il controllo (o il modello)
all’utente
Programmazione ad Oggetti
104
http://www.cis.ksu.edu/~schmidt/CIS200
visualizza il
valore corrente
inizializza il
contatore a zero
Programmazione ad Oggetti
L’architettura
Model View Controller
Contatore GUI 1
• Desideriamo una interfaccia
grafica per un contatore
(descritto nelle lezioni
precedenti) che contenga le
seguenti funzionalita`:
– un display per il valore
corrente
– tre bottoni per le
operazioni di incr(),
decr() e init(0)
public class Counter {
public Counter() {
[…]
}
[…]
public void init(int val){
c = val;
}
public void incr(){
c++;
}
public void decr(){
c--;
}
public int getVal(){
return c;
}
[…]
private int c;
private String nomeContatore;
}
107
• Le classi che formano l’applicativo possono essere
piu` facilmente riutilizzate
• L’applicativo e` organizzato in parti piu` semplici e
comprensibili (ogni parte ha le sue specifiche
finalita`)
• La modifica di una parte non coinvolge e non
interferisce con le altre parti (maggiore flessibilita`
nella manutenzione del software)
Programmazione ad Oggetti
108
18
MVC: sequenza dei messaggi
① viene premuto il
bottone
“Decrementa”
② l’evento e’ ascoltato
dal controller
①
③ il controller invia il
messaggio di decr()
al modello
④ il controller invia il
messaggio di
updateView() alla
vista
⑤ la vista richiede i dati
al modello per
aggiornarsi
(getVal())
view
model.getVal()
• E` alla base della programmazione delle GUI
• E` il nuovo tipo di input che deve essere trattato
nella programmazione delle GUI (pressione di
bottoni, mouse on/off, ecc.)
• L’utente genera tramite la GUI una serie di eventi a
cui il controllore deve prontamente reagire in
maniera opportuna
• Handling events: “processare” gli eventi
• Il controllore che processa gli eventi e` chiamato
event handler o event listener
• le informazioni sull’evento in Java sono
memorizzate in opportuni oggetti (EventObject)
model
⑤
0
-1
view.updateView()
②event
④
model.decr()
③
Action
Listener
actionPerformed(…)
controller
Programmazione ad Oggetti
110
Event-Driven Programming
• La computazione e` guidata completamente dalla
serie di eventi generati dall’utente
• Il programma processa gli eventi come input e
aggiorna il proprio modello interno e lo visualizza
tramite la vista
• Il controllo ha il compito di gestire il flusso di eventi
e dati dalla vista al modello e quindi nuovamente
verso la vista
• Piu` controllori, viste e modelli possono coesistere
a formare un programma
• Gli eventi devono essere generabili in maniera
coerente da parte dell’utente (disabilita/abilita)
111
Event-Driven Programming
① OS intercetta l’evento
“click di un bottone” e
lo comunica
all’AWT/Swing
② AWT/Swing determina
la sorgente dell’evento,
crea un ActionEvent e
lo invia all’incaricato
ActionListener
③ la procedura
actionPerformed
(event) del controllore
e` eseguita
④ il controllo invia gli
opportuni messaggi al
modello e alla vista
⑤ la vista si aggiorna
interrogando il modello
view
model.getVal()
model
⑤
0
①
-1
view.updateView()
②
④
model.decr()
ActionEvent
event
④
Action
Listener
actionPerformed(event)
③
Programmazione ad Oggetti
controller (e`
registrato come
ActionListener di
Decrementa)
112
AWT/Swing
• Ogni componente grafico (per esempio, un bottone)
mantiene al suo interno una lista di listener objects
(oggetti in ascolto)
• Un listener object ob è aggiunto alla lista di un
oggetto b tramite il messaggio
b.addActionListener(ob)
• In generale, un componente grafico può avere molti
listener objects e un listener object può “ascoltare”
più componenti
• Quando un evento occorre, la lista viene scandita e
a ogni listener object viene inviato il messaggio
actionPerformed
Programmazione ad Oggetti
Programmazione ad Oggetti
109
Event-Driven Programming
Programmazione ad Oggetti
Event-Driven Programming
113
• Componenti (component): oggetti che possono
avere una posizione e una dimensione nello schermo
e nei quali possono occorrere eventi
• Contenitori (container): componenti che possono
contenere al loro interno altre componenti come, ad
esempio, i pannelli (panel)
Programmazione ad Oggetti
114
19
AWT/Swing
Contatore GUI 1: view
Componente
• Finestre (windows): contenitori che possono essere
visualizzati direttamente sullo schermo
JLabel
JPanel
FlowLayout
JPanel
valore contatore: ...
BorderLayout
CENTER
SOUTH
• Frame: finestre con titolo e menu visualizzate
permanentemente sullo schermo durante
l’esecuzione di un programma
Decrementa
Reset
Incrementa
JPanel
FlowLayout
• Dialog: finestre visualizzate temporaneamente sullo
schermo durante l’esecuzione di un programma
(es. visualizzano messaggi di errore, input file, ecc)
Programmazione ad Oggetti
public class CounterControl implements ActionListener {
private Counter contatore;
private CounterInterfaceView contatoreVista;
public CounterControl(Counter cont, CounterInterfaceView contVista){
contatore = cont;
contatoreVista = contVista;
}
public void actionPerformed(ActionEvent e){
JButton source = (JButton)e.getSource(); // notare il cast!
if (source.getText().equals("Decrementa")) contatore.decr();
else if (source.getText().equals("Incrementa")) contatore.incr();
else contatore.init(0);
contatoreVista.updateView();
}
}
Programmazione ad Oggetti
invia
messaggi
model
Struttura del
contenitore
JPanel
Programmazione ad Oggetti
116
public class CounterView extends JPanel
implements CounterInterfaceView {
public CounterView(Counter model){
[…]
creazione del controllore
contatore = model;
[…]
controlloCounter = new CounterControl(contatore, this);
[…]
JButton bottoneDecr = new JButton("Decrementa");
bottoneDecr.addActionListener(controlloCounter);
[…]
aggancio
JButton bottoneReset = new JButton("Reset");
bottoneReset.addActionListener(controlloCounter);
[…]
JButton bottoneIncr = new JButton("Incrementa");
bottoneIncr.addActionListener(controlloCounter);
[…]
updateView();
}
Programmazione ad Oggetti
118
Contatore GUI 1: overview
①
0
invia
messaggi
crea
• la vista riceve il
modello tra i suoi main
eventi controller
parametri
Action
Listener
• il controllore riceve
actionPerformed(event)
tra i suoi parametri
la vista e il modello
③
Programmazione ad Oggetti
JButton
Componenti (in realta` sono
a loro volta contenitori, etichette,
icon, …)
117
Contatore GUI 1: MVC
crea
JButton
Contatore GUI 1:
aggangio del controller
• Tratta gli oggetti di tipo ActionEvent creati dall’AWT/Swing
contenenti tutte le informazioni sull’evento occorso
nell’interfaccia (vista)
• implementazione di ActionListener e definizione del
metodo actionPerformed(ActionEvent)
view
Contenitori
115
Contatore GUI 1:
controller
① Dal main si crea il
②
modello …
② … e la vista
③ la vista crea il
controllore (listener
bottoni) e lo
aggancia ai bottoni crea
JButton
119
• Diagramma delle
classi per il
contatore GUI 1
• Introduzione di una
interfaccia per la
vista
• ContatoreFrame
contiene il main e
quindi crea la vista
e il modello
• ExitButton e
ExitFrame
controllano l’uscita
dal programma
principale
Programmazione ad Oggetti
120
20
Cenni storici
• Il paradigma Object-Oriented (OO) non e` nuovo:
Simula, Smalltalk, C++
• “Green”, 1991 della Sun Microsystem, linguaggio
per dispositivi di consumo non legato ad un
particolare microprocessore
• HotJava, 1994, un browser per internet
• Netscape 2.0, 1995, abilitato all’uso di Java
• Java 1.02, 1996
• Java 1.1, 1997
• Java 2, 1998
JAVA:
dove e come
Programmazione ad Oggetti
Il “White paper” di Java
•
•
•
•
•
•
•
•
•
122
Dove trovare Java?
Semplice
A oggetti
Distribuito
Robusto
Sicuro
Indipendente dall’architettura
Portabile
Interpretato
Multithreaded
Programmazione ad Oggetti
Programmazione ad Oggetti
121
• Java e` disponibile
http://java.sun.com/j2se
(Java 2 Standard
Edition)
• Esistono versioni per:
– Sun Solaris
– Windows 95/98 e NT
– Linux (anche in RPM)
• Java 2 Runtime
Environment
• Java 2 S.E.
Documentation
Programmazione ad Oggetti
123
Dove trovare Java?
124
Cosa serve?
• … spesso anche dal vostro giornalaio (soluzione
consigliata se non si ha un collegamento a internet
veloce)
• Java e` distribuito gratuitamente dalla Sun
Microsystems
istruzioni di installazione
j2sdk1_3_0-win.exe
(29,4 Mb)
j2sdk1_3_0-doc.zip
(21,2 Mb)
• Attualmente e` disponibile la versione 1.3
tutorial.zip
(9,15 Mb)
Programmazione ad Oggetti
125
Programmazione ad Oggetti
126
21
Installazione di Java
Il Tutorial
• Per Windows… bastano due “click”
• Ricordarsi pero`:
– set PATH=%PATH%;C:¥JDK1.3¥BIN
• E` utile installarsi anche la documentazione e il
tutorial (in formato HTML)
• Nota: la Sun NON distribuisce alcun ambiente di
sviluppo, tutto viene eseguito dalla riga di comando
• Alcuni semplici editor sono (oltre il Notepad):
– TextPad (http://www.textpad.com/)
– WinEdt (http://www.winedt.com/)
Programmazione ad Oggetti
• Una semplice guida alla
programmazione in Java
• E` un ipertesto in HTML
quindi consultabile mediante
un qualsiasi browser
Programmazione ad Oggetti
127
La Documentazione
128
JDK1.3: il direttorio
Il nome del direttorio
di installazione
• Contiene TUTTE le
informazioni sulla versione
in uso di Java
• In particolare contiene il
Java 2 Platform API
Specification
• E` in formato HTML
Gli eseguibili:
• javac
• java
• javadoc
•…
La documentazione sulle
Librerie (in HTML)
Il tutorial di
Java (in HTML)
Esempi di
programmi Java
(e applet)
• Nota: il tutorial e la
documentazione NON sono
inclusi nell’installazione di
Java 2
I sorgenti delle
librerie
IMPORTANTE!!
set PATH=%PATH%;C:¥JDK1.3¥BIN
Programmazione ad Oggetti
129
Programmazione ad Oggetti
130
Applet
• Applet: speciali programmi Java che un browser
può scaricare dalla rete ed eseguire. La chiamata
dell'applet viene inserita in un documento HTML.
• (Non sono uno strumento per realizzare pagine
web)
JAVA
oltre ...
• Attualmente l'interesse è diminuito perché HTML ed
i linguaggi di scripting sono molto potenziati
rispetto ai primi tempi di Java.
• I principali browser non supportano più le ultime
versioni di Java. Occorre installare dei plug-in.
• Uso vantaggioso soprattutto in applicazioni intranet
aziendali.
Programmazione ad Oggetti
131
Programmazione ad Oggetti
132
22
Sicurezza delle applet
Sicurezza delle applet
• Le applet (diversamente dalle applicazioni) sono
limitate nelle operazioni che possono svolgere.
• I controlli sono effettuati dall'interprete della Java
Virtual Machine in base ad un modello predefinito di
gestione della sicurezza.
• Non possono avviare programmi locali.
• Non possono comunicare con host diversi da quello
da cui sono state prelevate.
• Non possono accedere al file system locale.
• Non possono recuperare informazioni riguardanti il
computer locale.
• Le applet possono essere firmate.
• Se chi firma l'applet è una persona di fiducia, è
possibile concedere più privilegi all'applet
modificando la politica di gestione della sicurezza.
Ad esempio si può concedere ad una applet di una
intranet aziendale di accedere ai file locali.
Spirograph Simulator
http://www.di.unito.it/~baldoni
Programmazione ad Oggetti
Programmazione ad Oggetti
133
Servlet e Web Server
134
Servlet e Web Server
Servlet:
Java Virtual Machine
HttpServletRequest
• estensioni del Java API
• permettono di scrivere applicazioni indipendenti
eseguite all’interno del Web server
• possono servire richieste in parallelo
• mantengono la sessione di lavoro con il singolo
utente
• efficienti e semplici da utilizzare rispetto ai
programmi CGI
Programmazione ad Oggetti
HttpServletResponse
Servlet
Client Browser
Web Server
135
Servlet e Web Server
Programmazione ad Oggetti
136
Servlet
• Ogni volta che il Web Server riceve una richiesta
per una servlet S:
• Una servlet è una classe Java (estensione di
HttpServlet).
• Un Web Server può ospitare più servlet (con relativi
alias)
• Quando il processo Web Server viene lanciato,
genera un thread Java che inizializza l’oggetto
Servlet (metodo init)
• Ogni servlet è un thread all’interno del Web Server
– identifica la servlet S
– invoca il metodo service dell’oggetto Servlet S,
per far eseguire le operazioni richieste
• Il metodo service rappresenta l’interfaccia del
secondo livello di applicazione. Al termine del
metodo, S rimanda una risposta sotto forma di
pagina HTML
• Il Web server spedisce la pagina al browser
chiamante
Programmazione ad Oggetti
137
Programmazione ad Oggetti
138
23
Servlet e Web Server
Comunicazione distribuita
Java VM2
• Apache, Netscape, Microsoft o Oracle Web Server
• le servlet erano inizialmente solo integrate nel Java
Web Server della Sun
Java VM1
Port 2
Port1
Invocazione di metodi
sull’oggetto remoto
Programmazione ad Oggetti
RMI: goal
• offrire un modello distribuito che preservi
maggiormente la semantica degli oggetti Java
• rendere il piu’ semplice possibile la scrittura di
applicazioni distribuite
Applicazione Client
Applicazione Server
Livello stub
Livello skeleton
Livello di riferimento
remoto
Livello di riferimento
remoto
Livello di Trasporto
141
Architettura RMI
Rete
Livello di Trasporto
Programmazione ad Oggetti
142
RMI
• Il sistema RMI é costituito da tre livelli per
supportare flessibilità nella comunicazione
• Ogni livello ha le sue interfacce di comunicazione
con relativi protocolli
– stub/skeleton layer: canale di comunicazione tra
clients e server
– remote reference layer: supporto di diversi
protocolli di invocazione tipo Unicast e Multicast
– transport layer: supporta la comunicazione a
basso livello, tipo TCP/IP
Programmazione ad Oggetti
140
Architettura RMI
• Rendere trasparente l’invocazione remota di metodi
su oggetti Java che risiedono su diverse Virtual
machines (evoluzione di Remote Procedure Call,
RPC)
Programmazione ad Oggetti
Programmazione ad Oggetti
139
143
Simile all’invocazione di metodi locali
• i parametri dei metodi possono essere oggetti
• il polimorfismo e’ supportato: oggetti diversi
possono rispondere a stessi messaggi
ma
• i client interagiscono con interfacce di oggetti
(stub) non con la loro implementazione (che sta
nella VM remota)
• parametri passati per copia, non per referenza
(passaggio per referenza solo dentro a una VM)
Programmazione ad Oggetti
144
24
Documentazione automatica
• javadoc permette di generare automaticamente file
di documentazione analizzando i commenti
compresi tra i simboli /** e */
• Produce documentazione in formato HTML
• La documentazione di Java sulle API e` generata
con tale utility
Together/J
•
della Object International Software Ltd.
• Together/J permette di mantenere la
sincronizzazione tra i diagrammi della
progettazione e il codice Java
• Facilita` la realizzazione di un programma orientato
agli oggetti integrando la progettazione con la
scrittura vera e propria del programma stesso
• package, classe pubblica, interfaccia pubblica,
metodo pubblico o protetto, variabile pubblica o
protetta
• Object Domain, Rational Rose, ...
Programmazione ad Oggetti
145
Bibliografia
146
Bibliografia
• Eckel, B.
Thinking in Java.
Second Edition.
Prentice-Hall Computer
Books, 2000.
ISBN: 0130273635
• Disponibile anche
gratuitamente all’indirizzo
http://www.bruceeckel.com
dove e` possibile trovare
anche “Thinking in C++”
dello stesso autore
Programmazione ad Oggetti
Programmazione ad Oggetti
147
• Horstmann, C.
S.Cornell, G.
Core Java 2:
Fundamentals.
Prentice Hall, 1999.
ISBN: 0130819336
Core Java 2:
Advanced Features.
Prentice Hall, 1999.
ISBN: 0130819344
• Anche in italiano:
Programmazione ad Oggetti
Java 2 i fondamenti.
McGraw Hill, 1999. e
Java 2 Tecniche
avanzate. McGraw Hill,
2000.
148
Bibliografia
Altri riferimenti:
• Schimdt, D. Programming Principles in Java:
Architectures and Interfaces.
http://www.cis.ksu.edu/~schmidt/CIS200/
• Fowler, M. UML Distilled (2nd ed.), Addison Wesley
Longman, Inc., 2000.
Programmazione ad Oggetti
149
25
