Java Programming Language

LA PROGRAMMAZIONE ORIENTATALA PROGRAMMAZIONE ORIENTATA
AGLI OGGETTIAGLI OGGETTI
JavaJava

PROGETTO DI SISTEMI
• Progettare un “sistema software” è cosa ben
diversa dal progettare un algoritmo
• “CRISI DEL SOFTWARE”: i costi di gestione
diventano preponderanti su quelli di
produzione
• Cosa occorre per ottenere un sistema che non
solo funzioni, ma che sia anche “ben fatto”?

SOFTWARE “BEN FATTO” … ?
• Ben organizzato
• Modulare
• Protetto
• Riusabile
• Riconfigurabile
• Flessibile
• Documentato
• Incrementalmente estendibile
• A componenti

LA COSTRUZIONE DEL SOFTWARE
 Ingredienti computazionali
– le mosse di un linguaggio
 Requisiti
– non basta un sistema che “funzioni”
 Principi
– regole per una buona organizzazione
 Modelli, Concetti, Paradigmi, Pattern
– fonti di ispirazione

LO SVILUPPO STORICO
 1950-1970:
– cosa significa computare?
– quali mosse primitive deve avere un linguaggio di
programmazione?
 1970-1980:
– quali principi di organizzazione del software?
– basta la programmazione strutturata?

 1980-1990:
– perché il modello a oggetti è importante?
– vi sono alternative alla classificazione?
 1990-2000:
– quali ripercussioni se la piattaforma
computazionale diventa una rete?
– come recuperare vecchie applicazioni
sulle nuove piattaforme?
 ...
LO SVILUPPO STORICO

PROGETTO & LINGUAGGI
I linguaggi di programmazione devono fornire
• non solo un modo per esprimere computazioni
• ma anche un modo per dare struttura alla
descrizione
• e un supporto per organizzare il processo
produttivo del software.

PROGETTO & STRUMENTI
PROBLEMA:
• le strutture dati e le strutture di controllo
(programmazione strutturata)
• le funzioni e le procedure
• file e moduli come “contenitori di descrizioni”
non bastano per ottenere software
modulare e sviluppabile in modo
incrementale. Perché?

LA “CRISI DIMENSIONALE”
Il cambio di dimensioni del problema cambia
• non solo le “dimensioni fisiche”
• ma anche le astrazioni, i modelli, gli strumenti più
opportuni per progettare
L’attenzione si sposta
dal singolo algoritmo (e da una o più funzioni)
alle entità del mondo reale da modellare
e agli strumenti che consentono il lavoro di gruppo

Programmi di piccole dimensioni
• enfasi sull’algoritmo
• programmazione strutturata
Programmi di medie dimensioni
• funzioni e procedure come astrazioni di
espressioni/istruzioni complesse
• decomposizione degli algoritmi in blocchi funzionali

Programmi di grandi dimensioni
• devono trattare grandi moli di dati, ma
• la decomposizione funzionale è inadeguata
• dati e funzioni che elaborano tali dati sono scor-relati:
nulla indica che le una agiscano sugli altri
• devono essere sviluppati da gruppi, ma
• la decomposizione funzionale e il disaccoppia-mento
dati/funzioni non agevolano la decompo-sizione del
lavoro
(segue)

Programmi di grandi dimensioni (segue)
• trattano dati relativi a entità del mondo reale
(persone, oggetti, grafici, documenti)
• interagiscono con entità del modo reale
• Tuttavia:
• le entità del mondo reale non sono "dati" su cui
operano delle funzioni
• sono entità che devono essere trattate in modo
coerente alla loro essenza

LA “CRISI GESTIONALE”
Il costo maggiore nel processo di produzione
del software è dovuto alla manutenzione
– correttiva (per eliminare errori)
– adattativa (per rispondere a nuove esigenze)
Programmi di piccole dimensioni
– trovare gli errori non è difficilissimo
– l’impatto delle modifiche è intrinsecamente limi-tato
dalle piccole dimensioni del programma

LA “CRISI GESTIONALE”
Programmi di medie dimensioni
• individuare gli errori è già più complesso
• l’impatto delle modifiche si propaga, a causa del non-
accoppiamento dati/funzioni, anche a fun-zioni o
procedure diverse da quella modificata.
Programmi di grandi dimensioni
• trovare gli errori può essere estremamente difficile e
oneroso
• data la propagazione delle modifiche, ogni
cambiamento coinvolge tutto il team di sviluppo.

L’OBIETTIVO
Costruzione di software
ben organizzato, modulare, protetto, riusabile,
riconfigurabile (dinamicamente?), flessibile,
documentato, incrementalmente estendibile, …
L'enfasi non è più tutta / solo / prioritariamente
su efficienza e su ottimizzazione.

EFFICIENZA… MA NON SOLO
 Premature optimization is the root of all evil
– Donald E. Knuth
 Make it work first, before you make it work fast
– Bruce Whiteside
 Make it fail-safe before you make it faster
 Make it clear before you make it faster
– Kernighan A. Plaugher

QUALE PROGETTO?
Spesso
 si studia un linguaggio
 si “pensa” in termini del linguaggio
conosciuto, usando
– i costrutti del linguaggio
– l’information space del linguaggio
– metodologie legate al linguaggio (idiomi,
framework )
– schemi standard (pattern)

Linguaggi: un po’ di storia
Albori: Macchine a programma memorizzato,
Programmi come dati
Linguaggio Macchina
Assemblatore
FORTRAN (calcolo scientifico) COBOL (Data Processing)
Anni ’60: Formalizzazione della sintassi, Strutture a
blocchi, implementazione del λ-calcolo
LISP (LISt Processing)
ALGOL
PL/I – ALGOL ‘68
(Linguaggio universale)

L’era moderna: Programmazione strutturata,
Metodologie, Astrazione, Linguaggi ad alto
livello per la programmazione di sistema
PASCAL
C ADA
Universale?
LISP
Varie versioni
della logica
PROLOG ML
Programmazione
orientata agli
oggetti
C++
JAVA

Paradigmi
Per paradigmi di programmazione si
intendono i “modi” in cui vengono
specificati i programmi
Non si tratta tanto del tipo di linguaggio
usato, ma del contesto più ampio al quale
un certo linguaggio appartiene
Parliamo di come viene organizzata la
programmazione, con quali
caratteristiche: stile, livello di dettaglio,
“forma mentis” del programmatore

Programmazione non strutturata
Programmazione procedurale
Programmazione modulare
Programmazione ad oggetti
Paradigmi di programmazione Lezione 1

Programmazione non strutturata
Lezione 1
Il programma è costituito da un unico blocco di codice detto "main" dentroIl programma è costituito da un unico blocco di codice detto "main" dentro
il quale vengono manipolati i dati in maniera totalmente sequenzialeil quale vengono manipolati i dati in maniera totalmente sequenziale

Programmazione procedurale
Lezione 1
Il concetto base è quello di raggruppare i pezzi di programma ripetuti inIl concetto base è quello di raggruppare i pezzi di programma ripetuti in
porzioni di codice utilizzabili e richiamabili ogni volta che se ne presentiporzioni di codice utilizzabili e richiamabili ogni volta che se ne presenti
l'esigenza; queste porzioni di codice sono chiamate procedure. Ill'esigenza; queste porzioni di codice sono chiamate procedure. Il
programma è costituito da un unico file.programma è costituito da un unico file.

Programmazione modulare
Lezione 1
Le procedure aventi un dominio comuneLe procedure aventi un dominio comune (ad esempio, procedure che eseguono(ad esempio, procedure che eseguono
operazioni matematiche) vengono raggruppate in moduli separati. Il programmaoperazioni matematiche) vengono raggruppate in moduli separati. Il programma
è costituito da più file.è costituito da più file.

Programmazione orientata agli oggetti (Object Oriented
Programming - OOP)
Lezione 1
E’ basato sul fatto che esistono una serie di oggetti che interagisconoE’ basato sul fatto che esistono una serie di oggetti che interagiscono
vicendevolmente, scambiandosi messaggi ma mantenendo ognuno il propriovicendevolmente, scambiandosi messaggi ma mantenendo ognuno il proprio
stato ed i propri dati.stato ed i propri dati.

Origini della programmazione ad oggetti
 Anni ’60: Simula 1 e Simula 67
 Anni ’70: Smalltalk
 Anni ’80: ADA – consacrazione della
programmazione ad oggetti
 Tra i più noti linguaggi di programmazione ad
oggetti: Java, C++, Delphi, C#, Visual
Basic.NET
Lezione 1

Motivazioni
 Migliorare la qualità del software
 I programmi di grandi dimensioni vengono
scomposti in moduli, che chiameremo oggetti
 Ne trae beneficio la fase di manutenzione
 Riutilizzo del codice
Lezione 1

Filosofia del corso
”per me non è importante che
il codice "funzioni", perché io do per scontato
che lo faccia. Le cose che
mi interessano sono altre, in primissimo
luogo la manutenibilità del codice
a distanza di anni e da parte di persone
diverse“
[un imprenditore IT]

Object Oriented Programming
 Introduzione
 Principi di OOP
 Classi ed oggetti
 Attributi, metodi e proprietà
 Incapsulamento
 Ereditarietà
 Polimorfismo
 Astrazione

A World of Objects
 Sin dalla loro introduzione negli anni 60, i principi della
programmazione ad oggetti hanno influenzato lo sviluppo del
software
 La Programmazione Orientata agli Oggetti (OOP) è un
paradigma che porta a suddividere un problema complesso in
parti (oggetti) in reciproca interazione tramite messaggi
 La filosofia di base porta a modellare il mondo reale attraverso
entità astratte (il telefono cellulare, una palla che rimbalza, i
numeri complessi) in maniera verosimile

Il paradigma ad oggetti
 Formalizza mediante le classi il concetto di modulo
che incapsula i dati e le procedure per modificarli
 Le classi si definiscono in una struttura gerarchica e
ereditano caratteristiche e funzionalità
 Obiettivo: migliorare l’efficienza del processo di
produzione e mantenimento del software

Pilastri della OOP
 Astrazione
– Il meccanismo con cui si specifica le caratteristiche peculiari di un
oggetto che lo differenzia da altri
 Incapsulamento dei dati
– Il processo di nascondere i dettagli di definizione degli oggetti, solo
le interfacce con l’esterno devono essere visibili
 Ereditarietà
– Gli oggetti sono definiti in una gerarchia ed ereditano
dall’immediato parente caratteristiche comuni, che possono essere
specializzate
 Polimorfismo
– Possibilità di eseguire funzioni con lo stesso nome che pure sono
state specializzate per una particolare classe

Introduzione agli oggetti
 Interagiamo con oggetti di uso quotidiano, conoscendone le
funzioni, ma non il funzionamento interno
– Gli oggetti sono scatole nere dotate di interfaccia che limita
l’accesso ai meccanismi interni
– Gli oggetti hanno uno stato
 L’insieme delle proprietà che lo caratterizzano in un dato istante
– e un comportamento
 L’insieme delle azioni che un oggetto può compiere
 Un oggetto sw è un’astrazione o un modello della realtà che
limita il numero dei dettagli rappresentati all’essenziale per il
contesto considerato

What’s in an object
 Un oggetto è caratterizzato da dei dati, ovvero dal
suo stato;
 Fornisce metodi per accedere e manipolare questi
dati, determinando il suo comportamento;
 Rappresenta una unità reale, cioè la sua identità.
 Un esempio:
L’oggetto telefono cellulare…

L’oggetto TelefonoCellulare
 Lo stato di un telefono cellulare può essere
caratterizzato da:
– E’ acceso o spento
– In che modalità si trova: stand-by, conversazione,
composizione
– Il volume audio, l’ultimo numero digitato.
 E’ possibile interagire con il telefono cellulare
mediante la tastiera o altri tasti di controllo
modificandone lo stato ed il comportamento.
 E’ possibile identificare univocamente il telefono
cellulare grazie al numero IMEI.

Astrazione
 L’astrazione nasconde o ignora dettagli inessenziali
 Effettuiamo astrazioni continuamente
– Possiamo trattare solo poche informazioni contemporaneamente
– Ma se raggruppiamo le informazioni (come gli oggetti) allora
possiamo trattare informazioni più complicate
 Un oggetto sw è un’astrazione
– Non ci preoccupiamo dei suoi dettagli interni per usarlo
– Non conosciamo come funziona il metodo println quando
l’invochiamo
 Quindi, possiamo anche scrivere software complesso
organizzandolo attentamente in classi e oggetti

Gli oggetti software
 Lo stato di un oggetto sw è descritto e
rappresentato da una o più variabili
– Una variabile è un dato individuato da un
identificatore
 il comportamento è definito dai metodi
 Un oggetto sw è costituito dall’insieme delle
variabili e dei metodi

Oggetti e classi
 Gli oggetti sono generati da una classe
– Si dicono anche istanze della classe
 La classe è uno schema per produrre una
categoria di oggetti identici di struttura
– La classe costituisce il prototipo
– La classe descrive le caratteristiche di un
oggetto
– Una classe è una fabbrica di istanze: possiede
lo schema e la tecnica di produzione

Gli oggetti come astrazione
 Un oggetto che modella una bicicletta
– Una velocità (20 Km/h), il giro dei pedali (15 g/m)
e la marcia (5°) sono variabili di istanza
– proprietà rappresentate in ciascuna bicicletta
modellata

Gli oggetti come astrazione – 2
 Inoltre nel modello rappresentiamo funzioni come frenare o
cambiare marcia, che modificano le variabili d’istanza
 Si chiamano metodi d’istanza perché hanno accesso alle
variabili d’istanza e le modificano

Le istanze
 Definita una classe, si possono creare un
numero arbitrario di oggetti appartenenti alla
classe

Incapsulamento dei dati
 Nascondere le informazioni fornendo un’interfaccia
 Le variabili di un oggetto, che ne rappresentano lo stato, sono
nascoste all’interno dell’oggetto, accessibili solo ai metodi
 Idealmente i metodi proteggono le variabili
 3 diversi livelli di accesso a metodi e variabili
– public: accessibili a chiunque
– private: accessibili solo alla classe
– protected: accessibili a classe, sottoclassi e pacchetto
 Consente modularità e flessibilità

Messaggi (1/3)
 Gli oggetti interagiscono tra loro per
ottenere funzioni più complesse
– La bicicletta appesa in garage è un
oggetto e basta, ci vuole un ciclista che
interagisca con lei perché diventi
interessante
 Gli oggetti sw per interagire si mandano
messaggi
– Chiedendo di eseguire un certo metodo
Il ricevente:

Messaggi (2/3)
 Spesso i metodi necessitano di
informazioni per poter essere
eseguiti:
i parametri
 Tre componenti:
– L’oggetto a cui il messaggio è
rivolto: il ricevente
– Il metodo da eseguire per
ottenere un certo effetto
– I parametri se necessari al
metodo
Il ricevente:
Il messaggio:

Messaggi 3/3
 Un oggetto può essere visto come un insieme di servizi che possiamo
chiedere di eseguire
 I servizi sono definiti dai metodi
 Il comportamento degli oggetti è definito dai suoi metodi e il
meccanismo di invio dei messaggi consente l’interazione tra gli oggetti
 Gli oggetti che si scambiano i messaggi possono anche essere
‘distanti’ tra loro
– Su macchine diverse
– Non appartenenti allo stesso modello

Interfaccia
 L’interfaccia è l’insieme dei messaggi che un
oggetto è in grado di interpretare
 Un oggetto deve soddisfare la richiesta di un
messaggio
 Eseguendo il metodo si soddisfa la risposta ad un
messaggio da parte di un agente
nome: carlo
marcia: 5
vel: 20
ciclista_A bicicletta_rossa
cambia (marcia)

Inviare messaggi
 Il ciclista ciclista_A che vuole cambiare
marcia invia il messaggio all’oggetto
bicicletta_rossa
bicicletta_rossa.cambia(2);
oggetto metodo i parametri
informazioni fornite al
metodo

Invocazione di un metodo
 Molte istruzioni sono invocazioni di metodi su oggetti
 La sintassi della chiamata del metodo:
 Chiediamo il servizio di stampa, invocando il metodo
println dell’oggetto System.out
System.out.println (“Hello deep and cruel Java World!");
oggetto
metodo i parametri
oggetto.nomeMetodo (parametri)

Metodi e oggetti
 I metodi possono essere invocati su oggetti della classe che
hanno quel metodo nella loro interfaccia
– Il metodo println si può applicare a oggetti della classe
PrintStream
System.out.println()
– Il metodo length si può applicare a oggetti della classe String
“salute a tutti”.length()
– Quindi causa errore chiamare:
“salute a tutti”.println()

I membri delle classi
 Le classi contengono 2 tipi di membri,
definiti per l’intera classe o per le singole
istanze
– Le variabili o i campi, che rappresentano lo stato
della classe o degli oggetti
– I metodi, che rappresentano il comportamento:
codice eseguibile sottoforma di istruzioni
 Il tipo di un oggetto è definito dalla classe di
appartenenza

Esempio
 La classe Point della libreria awt ha due
campi, x e y, che rappresentano le
coordinate del punto
 I campi sono dichiarati public, cioè
chiunque acceda alla classe Point può
modificarli
Class Point {
public int x, y;
}

 La classe Rectangle e i campi d’istanza
 I campi x e y rappresentano la posizione dell’angolo alto sinistro e i
campi width e height rispettivamente l’ampiezza e l’attezza
 Si noti che l’astrazione operata consiste nel considerare un rettangolo
come una collezione di 4 valori numerici
La classe predefinita Rectangle
Rectangle
20
15
10
5 x
y
height
width
(x, y)
h
e
i
g
h
t
width

Creare oggetti
 Gli oggetti vengono creati mediante uno speciale metodo di
istanziazione, detto costruttore
 L’operatore new seguito dal nome della classe istanzia un
nuovo oggetto con valori di default dei campi:
– new Rectangle()
– Costruisce un rettangolo con i 4 campi al valore 0
 o con i valori passati come parametri
– new Rectangle(5, 10, 15, 20)
– Costruisce l’oggetto raffigurato prima

L’operatore new
 Si usa per istanziare nuovi oggetti di una classe
 È un operatore unario e viene prefisso al proprio
argomento: un costruttore della classe
 new costruttore_classe() costituisce una
espressione
 Riporta un valore: un riferimento all’oggetto della
classe specificata dal costruttore
 Il riferimento viene generalmente salvato in una
variabile mediante assegnamento

In memoria
 La dichiarazione di una variabile oggetto
Rectangle scatola;
non causa la sua inizializzazione, che va effettuata
esplicitamente mediante l’operatore new:
Rectangle
20
15
10
5 x
y
height
width
scatola
scatola

Riferimenti a oggetti
 Il riferimento descrive la posizione dell’oggetto sullo
heap
 Più variabili possono fare riferimento allo stesso
oggetto
Rectangle scatola;
scatola = new Rectangle (5,10,15,20);
Rectangle contenitore = scatola;
 Ora scatola e contenitore si riferiscono allo
stesso oggetto

Errore comune
 Dimenticare l’inizializzazione di variabili oggetto
Rectangle mio_rettangolo;
* mio_rettangolo.translate (5, 5);
Saluti_2 salutaCarlo;
* salutaCarlo.diCiao();
 Le istruzioni * generano un errore: si applica un metodo a un
oggetto che non esiste ancora
 La dichiarazione serve solo per creare la variabile oggetto, ma
non per inizializzarla;
 L’inizializzazione va effettuata esplicitamente mediante la
chimata all’operatore new

Costruttori vs metodi
 I costruttori non sono metodi
 I costruttori non possono essere invocati su oggetti esistenti
 I costruttori non vengono invocati come i metodi mediante
l’operatore dot (.)
 I costruttori vengono invocati solo all’atto della generazione di
un oggetto tramite l’operatore new
 Errore:
Saluti_2 salutatore_di_Andrea;
* salutatore_di_Andrea.Saluti_2(“Andrea”);

Approccio orientato agli Oggetti (intro)
 Pensare e rappresentare problemi usando
concetti del mondo reale
 Oggetti: rappresentano proprietà e
comportamento in un unica entità
 Dati e comportamento in un unico oggetto
singolo
 Un oggetto è definito dal suo
– stato - descrive le sue caratteristiche
– comportamento - quello che può fare

Esempio
Ad esempio: il modello di una moneta
 Una moneta può essere lanciata per
consentire una scelta casuale tra due valori:
testa o croce
 Lo stato della moneta è la sua faccia
corrente (testa o croce)
 Il comportamento consiste nel fatto di poter
essere lanciata
 Il comportamento può modificare il suo stato
Dati: testa, crece
Stato=testa
•Lancimi-> modifica lo stato
moneta

Alcune differenze tra OO e procedurale
 OOP: dati e comportamento contenuti in un
oggetto singolo
 Procedurale: dati e comportamento sono
separati
 OOP: divide il problema in oggetti separati
che realizzano azioni relazionadosi o
utilizzando altri oggetti
 Procedurale: ad alte complessità si evidenzia
un cedimento del sistema
 OOP: manutenzione, riusabilità e modifiche
possono essere eseguite in modo più
semplice della programmazione procedurale

Esempio: conto corrente
 Programmazione procedurale:
– Decomposizione funzionale del problema
 Divisione del problema in moduli
 Struttura dati (Numero correntista, Nome correntista,
Saldo
 Implementazione delle funzioni per operare sui dati:
– Deposito(ID, #)
– Prelievo(ID, #)
– CaolcoInteressi(ID)
– ......

Esempio: conto corrente
 Programmazione ad Oggetti
– Dati e funzioni non sono entità separate
– Programma: insieme di oggetti, che sono istanze
di un tipo di dato astratto
ContoCorrente
NumeroCorrentista
NomeCorrentista
Saldo
NumeroOperazioni
Deposita(valore)
Preleva(valore)
CalcolaInteressi()
IncrementaNumeroOperzazioni
LeggiNumeroOperazioni()

OOP
 Esempio oggetto ContoCorrente
– Un particolare conto corrente è una ‘istanza’ del
tipo dati astratti
– Ogni oggetto deve essere creato per essere
utilizzato
 Esempio:
ContoCorrente cc = new ContoCorrente();
cc.Deposito(1000);

Modelli orientato agli Oggetti
 Modello ad oggetti
– Il mondo viene visto come un sistema di cose
Comportamento visibile
Un oggetto
Stato interno nascosto
Oggetto = stato + comportamento + identità

Passi per la modellazione
 Identificare gli oggetti
 Identificare il comportamento degli oggetti
 Identificare le relazioni tra gli oggetti
 Realizzare gli oggetti

Approccio orientato agli oggetti
 Caratteristiche di un oggetto:
– Attributi (Struttura dati)
– Comportamento
 Caratteristiche richiesto da un approccio
orientato agli oggetti
– Identità
– Polimorfismo
– Ereditarietà

Approccio orientato agli Oggetti
 Identità
– Oggetti sono distinti: ogni oggetto ha la sua
identità anche se i suoi attributi sono identici
– Esempio: due mele anche se di colore e forma
identiche sono due oggetti distinti
– Oggetti sono definiti tramite un linguaggio di
programmazione

 Polimorfismo
– Ancora persto per capire tale caratteristica
– “Il poliformismo, nella programmazione orientata
agli oggetti, permette diversi comportamenti da
parte della stessa operazione”

 Ereditarietà
– Creazione di una gerarchia tra gli oggetto o classe
– Esistenza di una super classe, un oggetto che
contiene tutti gli altri oggetti
– La superclasse fattorizza le proprietà comuni di
diverse classi
– Un oggetto o classe eredita tutte le proprietà della
super classe e aggiunge altre proprietà
– Normalmente le proprietà della super classe non sono
ripetute nelle sottoclassi
– se ripetute, in alcuni casi, si hanno degli effetti di
Polimorfismo

Parliamo di Classi
 Possiamo definire una classe per produrre
oggetti specifici
 Ad esempio: una classe per simulare il lancio
di una moneta
 Scriviamo la classe Moneta per
rappresentare il modello di una moneta

Cos’e’ una classe
• Una classe contiene la dichiarazione dei dati e dei metodi
int x, y;
char ch;
Dichiarazioni di dati
stato
Dichiarazioni di metodi
comportamento

Classi e istanza
faccia 0
moneta_1
Moneta()
lancia()
dammiFaccia()
int faccia;
class Moneta
Moneta
faccia 1
moneta_2
Moneta

Riassunto
 Programmi per computer sono simulazioni
digitali di modelli concettuali e fisici
 Un oggetto è una singola istanza di una
classe, che contiene la struttura e il
comportamento definiti dalla classe
 Spesso ci si riferisci a tali oggetti come
“istanze di una classe”

Programmazione ad oggetti
 Oggetti
 Classi
 Interazione tra oggetti
 Incapsulamento
 Interfaccia
 Accesso agli attributi

Classi
 Possono esistere più oggetti che hanno gli stessi attributi,
anche con valori diversi, e che dispongono degli stessi metodi.
Si dice che questi oggetti appartengono alla stessa classe
 Una classe specifica gli attributi, senza indicarne il valore, e i
metodi che devono avere gli oggetti che appartengono alla
classe
 La classe quindi crea più oggetti tutti con gli stessi attributi e gli
stessi metodi. Gli oggetti creati a partire da una classe vengono
chiamati istanze della classe
 Due istanze della stessa classe sono distinguibili solo per il
valore dei loro attributi, mentre il loro comportamento (metodo)
è lo stesso
Lezione 2

Classi
 La struttura di una classe è la seguente:
Lezione 2
<nome classe>
<attributo1>
<attributo2>
…
<metodo1>
<metodo2>
…
Diagramma
delle classi

Classi
 Esempio:
Lezione 2
Automobile
Velocità
Colore
Numero di porte
Marca
Avviati
Accelera
Fermati
Gira
Cambia marcia
Rifornisciti

INTERFACCIA E IMPLEMENTAZIONE
 L'interfaccia esprime una vista astratta di un
ente computazionale, nascon-dendone
– l'organizzazione interna
– i dettagli di funzionamento
 L'implementazione esprime
– la rappresentazione dello stato interno
– il codice
di un ente computazionale

ASTRAZIONE
 Si focalizza sul funzionamento
osservabile di un ente
 ”Abstraction helps people to think
about what they are doing”
– la struttura interna di un servitore è
inessenziale agli occhi del cliente
– basta assicurare il rispetto del contratto
stabilito dall’interfaccia.

INCAPSULAMENTO
 Si focalizza sull’implementazione di un
ente
 “Encapsulation allows program
changes to be reliably made with
limited effort”
Astrazione e incapsulamento sono
concetti complementari.

INDIPENDENZA DALLA RAPPRESENTAZIONE
 Incapsulamento comporta che la
rappresentazione concreta di un dato
può essere modificata
 senza che vi siano ripercussioni sul resto
del programma.

DAL DIRE AL FARE ...
 In assenza di precisi supporti linguistici,
in fase di codifica si può però
compromettere il livello di astrazione
e con esso la modularità e la riusabilità
della soluzione.

RAPPRESENTAZIONE & ASTRAZIONE
 Attraverso i costruttori di tipo (array,
struct, enum, etc.) il progettista può
definire strutture dati che siano la
rappresentazione concreta delle
astrazioni che ha in mente.
 Occorre catturare la semantica delle
astrazioni di dato, cercando di impedire
l’accesso diretto alla rappresentazione
concreta del dato.

JAVA: obiettivi di progetto del linguaggio
Nota storica: Il linguaggio JAVA (inizialmente Oak) è stato progettato
in origine per programmare i microchip di elettrodomestici
REQUISITI PROGETTUALI PRINCIPALI
• familiare
• object-oriented
• robusto
• efficiente
• sicuro
• portabile
• semplice
• concorrente
• dinamico
• distribuito

JAVA ha una sintassi familiare
-I progettisti di JAVA sapevano che un nuovo linguaggio
non avrebbe preso piede se non avesse avesse avuto una
sintassi familiare ai programmatori professionisti, così
scelsero di utilizzare quanto più possibile una sintassi
simile al C++
- JAVA non è comunque la versione “per Internet” di C++
-E’ un linguaggio fondato sulle necessità e sulle esperienze
di “veri” programmatori

JAVA è object-oriented
-JAVA risponde all’esigenza di realizzare sistemi software
facili da modificare e manutenere
- JAVA consente alti livelli di riusabilità del codice
- JAVA fornisce un’arsenale di classi per lo sviluppo di
interfacce utente e di applicazioni Internet impiegabili con
relativa facilità

JAVA è robusto
-Una delle principali fonti di crash dei programmi scritti in
C/C++ è l’uso scorretto dell’aritmetica dei puntatori:
JAVA non fornisce tipi puntatori, né tanto meno l’aritmetica
dei puntatori

Linguaggi compilati e interpretati
linguaggio
compilato
Il compilatore produce un
eseguibile in codicemacchina.
L’esecuzione sarà molto velocema
lo stesso eseguibile non può
essere usato su piattaforme
diverse.
linguaggio
interpretato
Il codice é indipendentedalla
piattaforma, ma deve essere
eseguito attraverso un interprete
che in genere è molto poco
efficiente.
Java ha un compilatore ed un interprete.

JAVA è efficiente
-Sebbene l’eseguibile prodotto dal compilatore JAVA sia
una sequenza di comandi per un interprete, ciò rende i
programmi JAVA mediamente poco più lenti
di corrispondenti programmi C++.
-La perdita di efficienza che ne deriva è più che accettabile
per il tipo di applicazioni cui è solitamente applicato JAVA,
tipicamente programmi altamente interattivi
-Altri linguaggi interpretati quali BASIC, Tcl, PERL,
presentano livelli di inefficienza tali da limitarne decisamente
la possibilità di utilizzo

JAVA è sicuro
-Il rischio di infezione virale o di introduzione di “cavalli di
Troia” nell’eseguire sul proprio computer programmi
convenzionali di provenienza incerta è molto alto. Ciò
rendeva la pratica di “scaricarsi” programmi eseguibili da
Internet qualcosa di poco sicuro e da evitare
-JAVA offre un ambiente di esecuzione sicuro confinando
il programma scaricato da Internet in un “firewall” da cui
non è possibile accedere ad altre parti del computer

JAVA è portabile (indipendente dalla
piattaforma)
-Programmi scritti in linguaggi convenzionali quali il C e il
C++ sono, almeno in teoria, portabili da una piattaforma
all’altra, a patto di ricompilarli per la nuova piattaforma
-Dei programmi scaricabili da Internet si ha a disposizione
spesso solo l’eseguibile, specifico per ciascun tipo di CPU se
si tratta di programmi scritti in C/C++
-Se pure fosse disponibile il sorgente del programma,
saremmo costretti a ricompilarlo prima di poterlo eseguire
- JAVA: la magia del Bytecode

JAVA è portabile: bytecode e macchina
virtuale
Codice
sorgente
Compilatore
Codice
oggetto
CPUCompilatore convenzionale
Codice
sorgente
Compilatore Bytecode
Macchina virtuale
per computer A
Compilatore JAVA
Macchina virtuale
per computer B
Macchina virtuale
per computer C

JAVA è semplice
-JAVA è facile da imparare e da impiegare in maniera
produttiva, soprattutto se si conosce la filosofia di fondo
della programmazione a oggetti e/o il linguaggio C++
-Le caratteristiche più complesse di C++ sono state escluse
da JAVA, oppure realizzate in maniera più semplice
-JAVA non comprende caratteristiche insolite o sorprendenti:
esiste sempre un numero ridotto di modi ben chiari e definiti
per eseguire un determinato compito
-A differenza di altri linguaggi sovraccarichi di caratteristiche
(esempio, ADA), JAVA ha un numero minimo di caratteristiche
di base, estensibili se necessario con l’uso di librerie

JAVA è concorrente
-JAVA fornisce gli strumenti per gestire flussi di controllo
concorrenti: i Thread e i meccanismi di sincronizzazione
-L’approccio facile alla concorrenza offerto da JAVA
permette di concentrarsi sul comportamento specifico del
programma, piuttosto che sul come realizzare e gestire il
mutlitasking

JAVA è dinamico
- I programmi JAVA gestiscono estensivamente informazioni
di tipo run-time per l’accesso agli oggetti durante
l’esecuzione (es. binding dinamico)

JAVA è distribuito
- JAVA gestisce i protocolli TCP/IP: accedere ad una risorsa
tramite un URL è del tutto analogo all’accedere a un file
- Invio di messaggi remoti: programmazione client/server

Programmazione
in Java
 Applicazione: programma eseguito dal sistema
operativo
 Applet: applicazione, allegata ad una pagina
ipertestuale HTML ed eseguita dal visualizzatore di
pagina (browser)
 Servlet: applicazioni eseguita sul lato server in
seguito ad una specifica richiesta

La classe
 Unità fondamentale della programmazione
orientata agli oggetti
 Una classe è costituita da almeno un nome, che
la identifica in modo univoco, e una coppia di
parentesi graffe { } che dovranno contenere il
corpo della classe (dichiarazioni e istruzioni)

I metodi
Le istruzioni devono essere contenute in particolari
moduli detti metodi
 un metodo ha una struttura simile a quella della
classe: è definito tramite un nome e una coppia
di parentesi graffe (blocco)
 I nomi dei metodi e delle classi possono essere
preceduti da altri termini (es. public, static, ecc.)

Applicazioni
 Un’applicazione deve sempre contenere il metodo
main (principale) entro al quale inserire le istruzioni
dalle quali avrà inizio l'esecuzione del programma.
Ad esempio:
public class Vuota {
public static void main(String args[ ]) {
// Inserire le istruzioni del programma
}
}

Commenti
/*
Commento di più righe
*/
// Commento di una riga
/** Commento di documentazione (Javadoc)

Identificatori
 Designano gli elementi della programmazione
 Possono essere composti da lettere, cifre, il carattere
_ e il carattere $
 Non possono iniziare con una cifra
 Simboli maiuscoli e minuscoli sono trattati come
caratteri diversi (case sensitive)
 Alcuni identificatori hanno un significato prestabilito:
parole chiave e riservate; questi identificatori non
possono essere ridefiniti

Parole chiave e riservate
abstract
boolean
break
byte
case
catch
char
class
const2
continue
default
do
double
else
extends
false1
final
finally
float
for
goto2
if
implements
import
instanceof
int
interface
long
native
new
null1
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
true1
try
void
volatile
while
1. parole riservate; 2. parole al momento non utilizzate

Tipi di dati (primitivi)
Interi
bit tipo
8 (±) byte
16 (±) short
32 (±) int
64 (±) long
Virgola mobile
(reali)
bit tipo
32 float
64 double
Tipo
Carattere
char (*)
(16 bit)
Logico boolean
(*) tipo char unicode a 16 bit
compatibile con i numeri interi

Dichiarazioni
Esempi
V
a
r
i
a
b
i
l
i
int n;
float x;
char c;
boolean enunciato;
int v[] = new int[3];
String parola;
Costanti final float IVA = 0,20;
Librerie import awt.*;

Operatori aritmetici
Operatore Simbolo
Addizione +
Sottrazione -
Moltiplicazione *
Divisione /
Modulo %
Incremento ++n; n++
Decremento --n; n--

Operatori logici
Operatore Simbolo
Negazione !
Congiunzione &&
Disgiunzione
Inclusiva
||
Disgiunzione
esclusiva
^

Operatori bitwise
Operatore Simbolo
Congiunzione &
Disgiunzione Inclusiva |
Disgiunzione esclusiva ^
Complemento ~
Operano su numeri interi bit per bit

Operatori bitwise (Esempi)
110
&
010
010
110
|
010
110
110
^
010
100
~101
=
010

Operatori di scorrimento (shifting)
Operatore Simbolo
Scorrimento a sinistra
con riempimento di zeri a destra
<<
Scorrimento a destra
con estensione del bit di segno da sinistra
>>
Scorrimento a destra con riempimento di
zeri a sinistra
>>>
Operano su numeri interi bit per bit

Operatori di
assegnazione e relazione
Operatore Simbolo
Di assegnazione =
Uguale ==
Diverso !=
Maggiore >
Minore <
Non maggiore <=
Non minore >=

Forme abbreviate
(esempi con operatori aritmetci)
Operazione Forma abbreviata equivale a
Addizione a += b a = a + b
Sottrazione a -= b a = a - b
Moltiplicazione a *= b a = a * b
Divisione a /= b a = a / b
Possono essere utilizzate anche con altri operatori binari

Caratteri speciali
(Sequenze escape)
Carattere Descrizione
n A capo (new line)
t Tabulazione
b Cancella a sinistra (backspace)
r Inizio riga (carriage return)
f Avanzamento pagina (form feed)
Barra inversa
” Virgolette
’ Apice

Conversioni di tipo
Implicita (automatica) esempio
A un tipo più ‘capiente’ viene assegnato
un tipo meno ‘capiente’
double ← float ← long ← int ← char ← short ← byte
int i = 24;
long n = i;
Esplicita (casting) esempio
Si indica di fronte alla variabile il nuovo tipo
tra parentesi: (nuovo_tipo) variabile;
long n = 24;
int i = (int) n;

Applicazioni: classe “Hello”
public class Hello
{ // Una classe per cominciare a lavorare con Java
public static void main(String[] args)
{ // Mostra la stringa “Ciao, come stai?”
System.out.println("Ciao, come stai?");
}
}

Applicazioni: classe “Somma”
public class Somma
{ // Calcola la somma di 4 e 5
public static void main(String[] args)
{
// dichiarazione variabili e assegnazione valori
int a = 4;
int b = 5;
// Mostra il risultato della somma
System.out.println(“a+b = “ + (a+b));
}
}

Selezione
if if (condizione) istruzione;
if
else
if (condizione) istruzione;
else istruzione;
if
else
(blocco)
if (condizione)
{ istruzione; istruzione; …; }
else
{istruzione; istruzione; …; }

Selezione multipla
switch
switch (i) // i variabile byte o short o int o char
{
case 1: istruzione;
break;
case 2: { istruz; istruz; …; }
break;
case 3: { istruz; istruz; …; }
break;
default:
{ istruz; istruz; …; }
}

Ciclo enumerativo
for
for (int i=start; i<=stop; i++)
{
istruzione; istruzione; …;
}
for (int i=start; i<=stop; i--)
{
}
Nota: si possono usare le istruzioni break o continue per uscire dal
ciclo o riprenderlo

Ciclo condizionato
do
while
do
{
} while (condizione);
while (condizione)
{
}

Inizializzazione degli oggetti
 Costruttore di default
– E’ l’inizializzazione eseguita automaticamente
se non sono stati definiti altri costruttori
 Il costruttore di una sottoclasse può
chiamare quello della superclasse tramite il
metodo super
– La chiamata a super deve essere la prima
istruzione del costruttore

Costruttori (1)
class MezzoDiTrasporto {
int velocitaMassima;
int numeroPasseggeri;
MezzoDiTrasporto (int velocitaMassima, int numeroPasseggeri) {
this.velocitaMassima = velocitaMassima;
this.numeroPasseggeri = numeroPasseggeri;
}
}
class Autoveicolo extends MezzoDiTrasporto {
String tipoDiMotore;
int potenza;
Autoveicolo (int velocitaMassima, int numeroPasseggeri, int potenza) {
super(velocitaMassima, numeroPasseggeri);
this.potenza = potenza;
}
}
class Furgone extends Autoveicolo {
int portata;
Furgone (int velocitaMassima, int potenza, int portata) {
super (velocitaMassima, 2, potenza);
this.portata = portata;
}
}
this.potenza = potenza;
this.portata =
portata;
this.velocitaMassima = velocitaMassima;
this.numeroPasseggeri = numeroPasseggeri;

Costruttori (2)
 Nell’ordine vengono eseguiti:
– costruttore delle classi padre
– inizializzazione campi locali
– esecuzione resto del codice del costruttore
 Esempio:
int portata;
Motore motore = new Motore();
Furgone (int velMax, int pot, int port) {
super (velMax, 2, pot);
portata = port;
}
}
1super (velMax, 2, pot);
2Motore motore = new Motore();
3portata = port;

Specificatori di accesso
 Organizzare le classi in librerie, ma quali
metodi e attributi di una classe si possono
usare?
 Definire per ogni membro della classe quale
visibilità offre ai possibili clienti
– può essere specificato sia per metodi che per
attributi
 Possibilità di accesso:
– (friendly)
– public
– protected
– private

(friendly)
 Accesso di default, non ha una clausola particolare
 tutte le classi all’interno dello stesso package hanno accesso
ai membri friendly (package access)
– Default package (friendly):
 classi che non appartengono a nessun package
 sono nella stessa directory
 La dichiarazione di quell’attributo o metodo lo rende
accessibile a tutti
(relazione fra classi: package)
Specificatori di accessoSpecificatori di accesso
publicpublic

 Nessuno può accedere a quel metodo o attributo eccetto la
classe stessa all’interno dei propri metodi
– lavoro cooperativo: ognuno può modificare quanto da lui
dichiarato privato senza alcun impatto sul codice degli altri
sviluppatori
– utile soprattutto per il multithreading
 Garantire accesso a attributi e metodi per le sole classi
derivate
(relazione fra classi: ereditarietà))
Specificatori di accesso
privateprivate
protected

Visibilità in Java
Package
Client
Client
metodoPublic
metodoFriendly
metodoProtected
metodoPrivate
Client
Server

package mialibreria.utilita;
public class StampaMessaggio {
StampaMessaggio() {
System.out.println("Costruttore classe StampaMessaggio");
}
void visualizzaMessaggio(String msg) {
System.out.println("*StampaMessaggio:"+msg);
}
public static void main (String[] arg) {
StampaMessaggio sm = new StampaMessaggio();
sm.visualizzaMessaggio(arg[0]);
}
}
 Dichiaro una classe senza specificare un qualificatore per il
costruttore
– Posso istanziare la classe solo all’interno del package ‘utilita’
Esempio (1)Esempio (1)

 Esempio precedente: public class
StampaMessaggio:
– attualmente non può esser utilizzata da nessun client
esterno al package. Non è stata specificato nulla:
friendly
import mialibreria.utilita.*;
class Registro {
}
}
No constructor matching StampaMessaggio() found in class
mialibreria.utilita.StampaMessaggio.
Esempio (2)

package mialibreria.utilita;
public class StampaMessaggio {
public StampaMessaggio() {
System.out.println("Costruttore classe StampaMessaggio");
}
public void visualizzaMessaggio(String msg) {
System.out.println("*StampaMessaggio:"+msg);
}
}
}
 Soluzioni:
– dichiarare la classe registro come appartenente al package: NO
– dichiarare public il costruttore e il metodo della classe di libreria perchè sono funzioni che
quella classe offre ai suoi clienti
Esempio (3)Esempio (3)

Riassumendo:
come consentire l’accesso ad un attributo di una classe?
1) Dichiararlo public
permette l’accesso a qualsiasi altra classe (client)
2) Non specificare clausole (friendly)
permette l’accesso da qualsiasi altra classe appartenente allo
stesso package
3) Dichiararlo protected
consente l’accesso a tutte le sottoclassi come se fosse un
membro public
4) Dichiararlo private e fornire appositi metodi su cui
effettuare controlli di accesso (opportune politiche)
setValue() - getValue()
Specificatori di accessoSpecificatori di accesso

Riutilizzo del codice
 Copia e incolla, ma:
– I sorgenti non sono sempre disponibili
– E’ necessario ripetere testing e debugging
 Composizione
– Le nuove classi contengono ed utilizzano le
funzionalità di quelle preesistenti
 Ereditarietà
– Estensione delle vecchie classi con nuove
funzionalità

Esempio di Composizione
 Autoveicolo composto
da:
– volante
– motore, che a sua
volta
è composto da:
 carburatore
 pistoni
 ...
– ...
class Carburatore {...}
class Pistone {...}
class Motore {
Carburatore
carburatore;
Pistone[] pistoni;
...
}
class Volante {...}
class Autoveicolo {
Motore motore;
Volante volante;
String modello;
...
}

Esempio di Ereditarietà
 Mezzo di trasporto
– ha velocità massima
– numero di passeggeri
– ....
 Autoveicolo
– è un mezzo di trasporto
– tipo di motore
– potenza
– ....
 Furgone
– è un autoveicolo
– portata
– ....
class MezzoDiTrasporto {
int velocitaMassima;
int numeroPasseggeri;
}
class Autoveicolo extends MezzoDiTrasporto {
String tipoDiMotore;
int potenza;
}
int portata;
String datiTecnici() {
return " portata = " + portata +
" potenza = " + potenza +
" velocità = " + velocitaMassima;
}
}

Ereditarietà vs composizione
 Quando è meglio usare la
Composizione ?
Quando è meglio usare l’Ereditarietà ?
 Esempio:
Rettangolo
colore
base
altezza
getColore()
getBase()
getAltezza()
Cerchio
colore
raggio
getColore()
getRaggio()

Esempio (1)
import java.lang.String;
class Figura{
private String colore;
Figura(String col) {
colore = col;
}
String getColore() {
return colore;
}
}
class Rettangolo {
private double altezza;
private double base;
private Figura figura;
Rettangolo (String col, double alt,
double bas) {
figura = new Figura(col);
altezza = alt;
base = bas;
}
return figura.getColore();
}
}
class Cerchio {
private double raggio;
private Figura figuraCer;
Cerchio (String col, double rag) {
figuraCer = new Figura(col);
raggio = rag;
}
return figuraCer.getColore();
}
}
Case sensitive

Rettangolo
base
altezza
getBase()
getAltezza()
Cerchio
raggio
getRaggio()
Figura
Colore
getColore()
Ereditarietà e riuso del codice

class Figura{
colore = col;
}
return colore;
}
}
class Rettangolo extends Figura {
double bas) {
super(col);
altezza = alt;
base = bas;
}
double getArea() {
return altezza * base;
class Cerchio extends Figura {
super(col);
raggio = rag;
}
double getArea() {
return raggio * raggio * 3.14;
}
}
Rettangolo
base
altezza
getBase()
getAltezza()
Cerchio
raggio
getRaggio()
Figura
colore
getColore()
Esempio (2)

Il problema dell’area
 Una figura ha sempre un’area, che non può
essere calcolata a priori
 Un rettangolo ha un suo modo peculiare per
calcolare l’area
 Un cerchio ha un altro modo per calcolare
l’area

Rettangolo
base
altezza
getArea()
Cerchio
raggio
getArea()
Figura
Colore
getColore()
getArea()
Ereditarietà e binding dinamico

Esempio (3)
class Figura{
colore = col;
}
String mioColore() {
return colore;
}
double getArea() {
return 0;
}
}
Rettangolo (String col, double
alt,
double bas) {
super(col);
altezza = alt;
base = bas;
}
double getArea() {
}
}
super(col);
raggio = rag;
}
double getArea() {
return raggio * raggio * 3.14;
}
}

Metodi Astratti
 In Figura è presente un
metodo getArea,
impossibile da
concretizzare
ignorando il tipo di
figura
 Si realizza il metodo
dichiarandolo abstract
 Tutte le sottoclassi
devono fornire
un’implementazione
del metodo per non
essere a loro volta
astratte
abstract class Figura {
colore = col;
}
return colore;
}
abstract double getArea();
}
Rettangolo (String col, double alt, double bas) {
super(col);
altezza = alt;
base = bas;
}
double getArea() {
}
}

Esempio (6)
class Inutile {
Rettangolo rettRosso = new Rettangolo("Rosso", 10, 20);
Quadrato quadGiallo = new Quadrato("Giallo", 40);
Quadrato quadVerde = new Quadrato("Verde", 15);
// rettRosso = quadGiallo; // ok rettRosso diventa un quadrato
// quadGiallo = rettRosso; // errore in compilazione
// quadGiallo = (Quadrato)rettRosso; // invalid cast a runtime
// rettRosso = quadVerde;
// quadGiallo = (Quadrato)rettRosso; // ora va bene
System.out.println(" ret rosso = " + rettRosso.getArea() );
System.out.println(" ret giallo = " + quadGiallo.getArea() );
}
}
class Figura{ ... }
class Rettangolo extends
Figura { ... }
class Quadrato extends
Rettangolo { ... }
class Cerchio extends Figura
{ ... }

Immagine = array di Figure
Polimorfismo: esempio
 Immagine = insieme di
figure
 Immagine = contenitore
di figure in grado di
stamparsi
Rettangolo
......
......
Quadrato
Figura
......
......
Cerchio
......
......

Esempio (7)
abstract class Figura{
colore = col;
}
return colore;
}
abstract void stampati();
}
double bas) {
super(col);
altezza = alt;
base = bas;
}
void stampati() {
System.out.println(" sono un rettangolo"
+ getColore());
}
}
super(col);
raggio = rag;
}
void stampati() {
System.out.println(" sono un cerchio " +
getColore());
}
}
class Immagine {
Figura figure[] = new Figura[10];
int contatore = 0;
void addFigura(Figura newFig) {
figure[contatore++] = newFig;
}
void stampa() {
for (int i = 0; i < contatore; i++)
figure[i].stampati();
}
public static void main ( String args[ ]) {
Immagine immagine = new Immagine();
immagine.addFigura(new Rettangolo("verde", 10,20));
immagine.addFigura(new Cerchio("rosso", 15));
immagine.stampa();
}
}

Vantaggi del polimorfismo
 Aggiunta della classe Quadrato
 In Immagine è stato utilizzato il polimorfismo
(metodo generico addFigura()), quindi non bisogna
cambiare niente
 Con metodi diversi (addRettangolo(), addCerchio(),
…) l’aggiunta della classe quadrato implica una
modifica alla classe Immagine (aggiunta del metodo
addQuadrato())
class Quadrato extends Rettangolo {
Quadrato (String col, double lato) {
super(col, lato, lato);
}
void stampati() {
System.out.println(" sono un quadrato " +
getColore());
}
}

Ereditarietà multipla
Pianoforte
Oggetto di legno
Strumento
musicale
 Una classe può avere più padri di pari livello
 In Java non è consentita, per la fragilità del meccanismo
 Realizzata attraverso il concetto di interfaccia.

Interfacce
 Un’interfaccia è una collezione di metodi privi di
implementazione e costanti.
 Si usano per definire l’insieme di metodi che devono
essere concretizzati dalle classi che implementano
l’interfaccia
 Se una classe implementa un’interfaccia, il compilatore
verifica che esistano definizioni per tutti i relativi metodiclass interface
extends implements

Interfacce: esempio (8)
interface Strumento {
String descrizione = "azioni di uno strumento musicale generico";
// valore implicitamente static e final
void suona() ; // notare l’assenza della implementazione
String nome() ;
}
class flauto implements Strumentoclass flauto implements Strumento {
public void suona() {
System.out.println(" fiuuu");
}
public String nome() {
return "flauto";
}
public String descrizione() {
return "sono un flauto di marca";
}
}

Esempio di interfacce
interface Strumento
{
suona ( );
nome ( );
}
interface InVendita {
prezzo ( );
disponibile ( );
} Pianoforte In Vendita
Implements
Implements
Oggetto di legno
Extends

Interfacce
 Una classe può estendere una sola classe
ma può implementare un numero illimitato di
interfacce
class PianoforteInVendita extends
OggettoDiLegno
implements Strumento, InVendita {
...
}
 Un pianoforte in vendita è un oggetto di
legno e uno strumento musicale è un bene in
vendita

Ereditarietà multipla e Java
 Impedita per classi
– 1 solo "extends"
 Permessa per interfacce
– numero non limitato di "implements"
 Interfacce come classi astratte pure, i cui
metodi sono tutti vuoti
– comportamento sempre univoco e "pulito" (più o
meno)

Il metodo toString()
 Restituisce la rappresentazione testuale di un
oggetto
 E’ definito in Object e quindi presente in ogni oggetto
 E’ chiamato automaticamente o esplicitamente nelle
operazioni con le stringhe
– utilizzando il codice di default
– utilizzando il metodo ridefinito
 Esempi di utilizzo:
System.out.println("esempio: "+(new Integer(3)));
System.out.println("esempio: "+(new Cerchio("red",12)));

Esempio (4)
class Inutile {
Rettangolo rettRosso = new Rettangolo("Rosso", 10,
20);
Quadrato quadGiallo = new Quadrato("Giallo", 40);
Cerchio cerchioBlu = new Cerchio("blu", 15);
System.out.println("che tipo sei? " + rettRosso);
System.out.println("che tipo sei? " + quadGiallo);
System.out.println("che tipo sei? " +
cerchioBlu.toString());
}
}
Class Figura {
public String toString() {
return "sono una figura";
}
...
}
return "sono una figura con
angoli";
}
...
}
class Quadrato extends Rettangolo
{
...
}
return "sono una figura senza
angoli";

Esempio (5)
class Inutile {
Figura figura = new Figura("Verde");
Cerchio cerchioBlu = new Cerchio("blu", 15);
System.out.println("che tipo sei ? " + figura.toString() );
figura = cerchioBlu;
System.out.println("che tipo sei ? " + figura.toString() );
}
}
Class Figura {
return "sono una figura";
}
...
}
return "sono una figura con
angoli";
}
...
}
class Quadrato extends Rettangolo {
...
}
return "sono una figura senza
angoli";

overloading
L'overloading consente di definire in una
stessa classe più metodi aventi lo stesso nome
(ridondanza), ma che differiscano nella
firma, cioè nella sequenza dei tipi dei parametri
formali. È il compilatore che determina quale
dei metodi verrà invocato, in base al numero e
al tipo dei parametri attuali.

Overriding
L'overriding, invece, consente di ridefinire un
metodo in una sottoclasse: il metodo originale
e quello che lo ridefinisce hanno necessariamente
la stessa firma, e solo a tempo di esecuzione si
determina quale dei due deve essere eseguito
(polimorfismo).

Late Binding - binding dinamico
 Il polimorfismo è particolarmente utile quando la
versione del metodo da eseguire viene scelta sulla
base del tipo di oggetto effettivamente contenuto in
una variabile a runtime (invece che al momento della
compilazione). Questa funzionalità è detta binding
dinamico (o late-binding), e richiede un grosso sforzo
di supporto da parte della libreria runtime del
linguaggio.
 Se ho una variabile di tipo A, e il tipo A ha due
sottotipi (sottoclassi) B e C, che ridefiniscono
entrambe il metodo m(), l'oggetto contenuto nella
variabile potrà essere di tipo A, B o C, e quando sulla
variabile viene invocato il metodo m() viene eseguita
la versione appropriata per il tipo di oggetto
contenuto nella variabile in quel momento.

Esercizio - Dadi
 Disegnare e scrivere un’applicazione che
simuli una partita a dadi tra due giocatori.
 Ogni giocatore lancia il proprio dado, il quale
rotola e espone una faccia (valori tra 1 e 6).
 Si vogliono visualizzare N tiri di dado sulla
console.

Input / Output
Spesso un programma deve
acquisire dati da una sorgente
esterna o inviare informazioni a
una destinazione esterna.
L’informazione può essere di ogni
tipo:
 caratteri,
 immagini,

Input / Output
Stream di Input / Output
 Per acquisire dati, un programma apre uno stream (o
flusso)associato alla sorgente di informazione (file,
socket, memoria, ecc.) e legge l’informazione
sequenzialmente da esso.
 In modo analogo, un programma puo’ inviare verso
una destinazione esterna dei dati aprendo uno
stream associato alla destinazione e scrivendovi in
modo sequenziale i dati.
 Indipendentemente dall’origine e dalla destinazione
dei dati e dal loro tipo, gli algoritmi per leggere e
scrivere sequenzialmente dei dati sono gli stessi.

Input / Output
Lettura Scrittura
Apertura dello
stream
Finché e’
presente
informazione
lettura
dell’informazione
Apertura dello
stream
Finché e’
presente
informazione
scrittura
dell’informazione

Tipi di Stream
 Le classi di gestione degli stream sono di due tipi in
base ai dati
 su cui operano (caratteri/byte).
– Stream di Caratteri: classi Reader e Writer
– Stream di Byte: classi InputStream e OutputStream
(di solito usati per leggere file di immagini e suoni).
 Esistono varie sottoclassi che consentono la
lettura/scrittura su file:
– FileReader e FileWriter (file di testo)

Classi FileReader e FileInputStream
 Lettura
 Per leggere caratteri da un file si crea un oggetto
di tipo FileReader.
 FileReader(String fileName)
 Esempio:
 FileReader reader = new
FileReader(“input.txt”);
 Si utilizza il metodo int read() che legge un
carattere per volta e restituisce un valore di tipo
int.

Scrittura di dati su file
 Scrittura
 Si utilizza analogamente la classe FileWriter
per scrivere in un file sequenze di caratteri.
 FileWriter writer = new FileWriter
(“output.txt”);
 Si utilizza il metodo void write(int c) che
scrive un carattere per volta.
 Tale valore corrisponde al codice del carattere da
scrivere nel file.

 ⇔
 Chiusura di un file

Copia di un file
1. import java.io.*;
2.
3. public class CopyChars {
4. public static void main(String[] args)
5. throws IOException {
6. FileReader in = new FileReader(args[0]);
7. FileWriter out = new FileWriter(args[1]);
8. int c;
9.
10. while ((c = in.read()) != -1)
11. out.write(c);
12.
13. in.close();
14. out.close();
15. }
16. }

Classe BufferedReader
 Un BufferedReader permette di gestire un
flusso tramite un buffer.
– I dati vengono letti a blocchi dal flusso e
memorizzati in un buffer (area di memoria).
– Quando viene richiesto un nuovo dato prima si
verifica la sua disponibilità nel buffer e, se non
disponibile in memoria, si legge un nuovo blocco.
Metodi disponibili in aggiunta a quelli di Reader
String readLine()
Legge una riga e la restituisce sotto forma di stringa
Costruttori disponibili
BufferedReader(Reader in)
Crea un oggetto BufferedReader a partire da un oggetto Reader

Lettura bufferizzata
 FileReader file = new FileReader
(“nome-file”);
 BufferedReader in = new BufferedReader
(file);
 oppure
 BufferedReader in = new BufferedReader
(new FileReader (“nome-file”));
 Lettura di una riga:
 in.readLine();

Lettura
2.
3. public class testLettura {
6. FileReader file = new FileReader(args[0]);
7. BufferedReader in = new BufferedReader(file);
8. String line;
9. while ((line = in.readLine()) != null)
10. System.out.println(line);
11.
12. in.close();
13. }
14. }

Classe PrintWriter
 La classe PrintWriter mette a disposizione i
metodi void print() e void println()
utilizzabili con qualunque tipo di parametro
(stringa, intero, reale, ecc.).
 Si può creare un nuovo oggetto PrintWriter a
partire da un Writer, in particolare da un
FileWriter.
 PrintWriter f = new PrintWriter (
 new FileWriter (“nome-

Copia file
2.
3. public class testCopia {
8. String line;
9. PrintWriter out = new PrintWriter (new
FileWriter(args[1]));
10. while ((line = in.readLine()) != null)
11. out.println(line);
12.
13. in.close();
14. out.close();
15. }
16. }

Classe StringTokenizer
 La classe StringTokenizer e’ definita nel package
java.util.
 Un oggetto StringTokenizer separa una stringa in
sottostringhe dette token.
 Per default, il tokenizer separa la stringa ad ogni spazio.
 Il costruttore StringTokenizer richiede come parametro la
stringa da separare.
 Ciascuna chiamata al metodo nextToken restituisce il token
successivo.
 Esempio:
 1 23 4 -56 65 21 32 15 0 -3

Classe StringTokenizer
 The string tokenizer class allows an application to break
a string into tokens.
 Constructor Summary
 StringTokenizer(String str)
Constructs a string tokenizer for the specified
string.
 StringTokenizer(String str, String delim)
Constructs a string tokenizer for the specified
string.
 Method Summary
 int countTokens()
Calculates the number of times that this
tokenizer's nextToken method can be called before it
generates an exception.

Lettura token
2. import java.util.*;
3. public class testLetturaToken {
6. if(args.length>0){
9. String line;
10. while ((line = in.readLine()) != null) {
11. StringTokenizer st = new StringTokenizer(line);
12. while(st.hasMoreTokens())
13. System.out.println(st.nextToken());
14. }
15. in.close();
16. }
17. }
18. }

Esempio
 line:
– 1 23 4 -56 65 21 32 15 0 -3
 output:
– 1
– 23
– 4
– -56
– 65
– 21
– 32
– 15
– 0
– -3

Input da tastiera
 Lo standard input di un computer è visto attraverso l’oggetto
predefinito System.in
 Questo oggetto mette a disposizione un numero limitato di operazioni
 Esistono delle classi predefinite che a partire da questo oggetto
creano nuovi oggetti con maggiori funzionalità
 La classe InputStreamReader
 Un InputStreamReader converte una sequenza di byte in una sequenza
di caratteri in accordo con uno specifico sistema di codifica.
• La classe BufferedReader
• Un BufferedReader legge una sequenza di caratteri, la memorizza in un
buffer in modo da fornire funzioni per la lettura di intere linee.
1. InputStreamReader reader = new InputStreamReader(System.in);
2. BufferedReader console = new BufferedReader(reader);
• Dopo queste operazioni posso utilizzare l’oggetto console e il
metodo readLine() in grado di restituirmi una linea da tastiera (tutti i
caratteri immessi fino alla pressione di un fine linea) sotto forma di
stringa.
•

Esercitazione – Il Giornale
Realizzare Diagramma delle Classi, Diagramma di
sequenza e Implementazione relativi alle seguenti
specifiche:
Si vuole realizzare un’applicazione che permetta di
stampare a video la prima pagina di un giornale.
Tale pagina è costituita da tre sezioni: Alto Basso e
Centro.
L’applicazione deve leggere il testo di ogni sezione in un
file di testo fatto in questo modo:
Titolo: il titolo dell’ articolo
Sottotitolo: il sottotitolo
Corpo: Il corpo….

Le classi del JDK
Contenitori
 Collection
 Set
 List
 Iterator
 ListIterator
Gestione tempo
 (Date)
 GregorianCalendar

L’interfaccia Collection
Collection
add(arg0 : Object) : boolean
addAll(arg0 : Collection) : boolean
clear() : void
contains(arg0 : Object) : boolean
containsAll(arg0 : Collection) : boolean
equals(arg0 : Object) : boolean
hashCode() : int
isEmpty() : boolean
iterator() : Iterator
remove(arg0 : Object) : boolean
removeAll(arg0 : Collection) : boolean
retainAll(arg0 : Collection) : boolean
size() : int
toArray() : Object[]
toArray(arg0 : Object[]) : Object[]
(from util)
<<Interface>>  Metodi principali:
– add(): aggiunge l’oggetto
specificato alla Collection
– contains(): verifica la presenza
dell’oggetto specificato
– isEmpty(): verifica se l’insieme
è vuoto o no
– remove(): elimina l’oggetto
specificato dall’insieme
– iterator(): restituisce un oggetto
Iterator per scandire gli
elementi (sostituisce
elements() del Vector)

L’interfaccia Set
Set
clear() : void
hashCode() : int
isEmpty() : boolean
size() : int
(from util)
<<Interface>>
Collection
(from util)
<<Interface>>
 Le funzionalità offerte
coincidono con quelle offerte
dall’interfaccia Collection
 Le differenze sono di tipo
semantico:
– questa struttura non consente
l’ordinamento degli elementi
– non è prevista la presenza di
duplicati

L’interfaccia List
List
add(arg0 : int, arg1 : Object) : void
addAll(arg0 : int, arg1 : Collection) : boolean
clear() : void
get(arg0 : int) : Object
hashCode() : int
indexOf(arg0 : Object) : int
isEmpty() : boolean
lastIndexOf(arg0 : Object) : int
listIterator() : ListIterator
listIterator(arg0 : int) : ListIterator
remove(arg0 : int) : Object
set(arg0 : int, arg1 : Object) : Object
size() : int
subList(arg0 : int, arg1 : int) : List
(from util)
<<Interface>>
Collection
(from util)
<<Interface>>
 Realizza un insieme ordinato
(sequenza) di elementi
– l’ordinamento è esplicitato dalla modalità
di inserimento degli oggetti
– permette anche l’inserimento di duplicati
 Metodi principali:
– get(): elemento nella posizione
specificata
– lastIndexOf(): posizione dell’elemento
specificato
– listIterator(): dà accesso ad un Iterator
speciale in grado di usare l’ordinamento
– set(): inserisce un elemento alla
posizione specificata
– subList(): restituisce la sottolista
specificata

L’interfaccia Iterator
Iterator
hasNext() : boolean
next() : Object
remove() : void
(f rom util)
<<Interface>>
 Sostituisce l’interfaccia Enumeration
del JDK 1.1
 Metodi:
– hasNext(): verifica se ci sono altri
elementi
 sostituisce hasMoreElements() di
Enumeration
– next(): prossimo elemento nell’elenco
 sostituisce nextElement() di Enumeration
– remove(): elimina l’elemento corrente
dall’elenco
 metodo non presente in Enumeration (read-
only)

L’interfaccia ListIterator
ListIterator
add(arg0 : Object) : void
hasNext() : boolean
hasPrevious() : boolean
next() : Object
nextIndex() : int
previous() : Object
previousIndex() : int
remove() : void
set(arg0 : Object) : void
(from util)
<<Interface>>
Iterator
(from util)
<<Interface>>
 Permette di sfruttare l’ordinamento degli
oggetti
– è prodotta a partire da una List
(sequenziale)
 Metodi aggiuntivi:
– add(), remove(): aggiunge/rimuove un
elemento alla/dalla struttura
– hasPrevious(): verifica se c’è un
elemento precedente rispetto a quello
attuale
– previous(): elemeno precedente rispetto
a quello attuale
– set(): sostituisce l’elemento attuale
– nextIndex(), previousIndex(): restituisce
la posizione in cui ci si trova nella

Un esempio con List ed Iterator
import java.util.*;
public class SimpleCollection2 {
public static void main(String[] args) {
List l = new ArrayList();
for(int i = 0; i < 10; i++)
l.add(Integer.toString(i));
ListIterator listIt = l.listIterator();
while(listIt.hasNext()) {
System.out.println( “Elemento in posizione:
“ + listIt.nextIndex() );
System.out.println(listIt.next());
}

Eccezioni
 L’istruzione try/catch
 La propagazione dell’eccezioni
 Intercettare e gestire eccezioni

Eccezioni in breve
 Un’eccezione è un oggetto che descrive una
situazione anomala o di errore
 L’eccezioni vengono lanciate da una parte di un
programma e possono essere raccolte e gestite da
altre parti del programma
 Un programma può perciò essere suddiviso nel
normale flusso d’esecuzione e in quello eccezionale
 Anche un errore è rappresentato come un oggetto
Java, ma solitamente rappresenta una situazione non
recuperabile e da non gestire

Gestire l’eccezioni
 Java ha un insieme predefinito di eccezioni ed errori
che possono accadere durante l’esecuzione di un
programma
 3 modi di gestire l’eccezioni:
– Ignorarle
– Gestirle quando avvengono
– Gestirle altrove nel programma
 La scelta del modo di gestire gli eventi anomali o
eccezionali è un’importante caratteristica del disegno
del programma

Ignorare l’eccezioni
 Se un’eccezione è ignorata da un
programma, questo terminerà producendo
un messaggio opportuno
 Il messaggio mostra la traccia dello stack
delle chiamate dei metodi con l’indicazione:
– dell’errore
– della linea in cui l’eccezione si è verificata
– dellle chiamate di metodi che hanno portato
all’eccezione

Esempi
 Zero.java può causare un’eccezione
java.lang.ArithmeticException: / by zero
at Zero.calcolaQuoziente(Zero.java:27)
at Zero.main(Zero.java:21)
Exception in thread "main" Process Exit...
 BasicArray_eccezione.java causa l’eccezione
java.lang.ArrayIndexOutOfBoundsException
at
BasicArray_eccezione.main(BasicArray_eccezione.
java:30)

Esempi
 Postfissa.java può causare eccezioni
java.util.EmptyStackException
at java.util.Stack.peek(Stack.java:82)
at java.util.Stack.pop(Stack.java:64)
at Postfissa.elabora(Postfissa.java:37)
at Postfissa.main(Postfissa.java:21)
Exception in thread "main" Process
java.lang.NumberFormatException: 1=
at java.lang.Integer.parseInt(Integer.java:423)
at java.lang.Integer.<init>(Integer.java:549)
at Postfissa.elabora(Postfissa.java:42)
at Postfissa.main(Postfissa.java:21)

Gestire l’eccezioni
 Occorre processare l’eccezione quando accade, la
linea di codice che lancia l’eccezione deve essere
eseguita in un blocco try.
 Un blocco try è seguito da 1 o più clausole catch,
che contengono il codice per gestire l’eccezione
 Ogni clausola catch è associata ad un tipo
d’eccezione e viene chiamata exception handler
 Quando si solleva un’eccezione, la computazione
prosegue fino alla prima clausola catch che
corrisponde al tipo d’eccezione sollevata

L’istruzione try
 Si tenta di eseguire il codice e se si intercetta
un’eccezione si cerca di porre rimedio
try
{
blocco_1
}
catch (tipo_eccezione identificatore)
{
blocco_2
}
 L’istruzione try identifica un blocco d’istruzioni in
cui può verificarsi un’eccezione

La clausola catch
 Un blocco try è seguito da una o più clausole
catch, che specificano quali eccezioni vengono
gestite
– Ogni clausola catch corrisponde a un tipo di
eccezione sollevata
 Quando si verifica un’eccezione, la computazione
continua con la prima clausola che corrisponde
all’eccezione sollevata
 Divisione.java modifica Zero.java
 Postfissa_e.java
 ProductCodes.java

La clausola finally
 Un’istruzione try può essere seguita da
una clausola finally opzionale
 Le istruzioni della clausola finally
vengono sempre eseguite:
– Se non viene sollevata nessuna eccezione,
vengono eseguite dopo che si è concluso il
blocco try
– Se si verifica un’eccezione, vengono eseguite
dopo le istruzioni della clausola catch
appropriata

Rientro dai metodi in caso d’eccezioni
 Normalmente se un metodo main richiama il
metodo_1 che richiama il metodo_2 che
richiama il metodo_3, il controllo passa dal
main al metodo_1 al metodo_2 al
metodo_3 e quando questo si conclude
ritorna al metodo_2 che a conclusione lo
passa al metodo_1 e quindi al main
 Se si verifica un’eccezione durante
l’esecuzione del metodo_3 il controllo viene
passato diversamente

Propagazione dell’eccezioni
 Se l’eccezione non viene intercettata e gestita dove si
verifica, può ancora essere trattata a un livello più
alto
 L’eccezioni si propagano attraverso la gerarchia
delle chiamate di metodi finché non vengono
intercettate e gestite
 Propagation.java con la classe
ExceptionScope.java

L’istruzione throw
 Un programmatore può definire un’eccezione
estendendo una classe
– La classe Exception o una sua sottoclasse
 L’eccezioni vengono sollevate con l’istruzione
throw
 Solitamente un’istruzione throw è inclusa in
un’istruzione if che valuta una condizione per
verificare se deve essere sollevata l’eccezione
 CreatingExceptions.java con l’eccezione
EccezioneFuoriIntervallo.java
 CreatingExceptions_2.java

Classificazione dell’eccezioni
 Le eccezioni possono essere controllate
– Dovute a eventi esterni al programma
 Cercare di accedere a una pagina web inesistente
 Cercare una funzione di libreria che manca
– Si chiamano controllate perché il compilatore
controlla che vengano esplicitamente indicate e
intercettate
 O non controllate
– Dovute al programma e che potrebbero essere
evitate

Eccezioni controllate
 Un’eccezione controllata deve essere raccolta da un
metodo in una clausola catch o deve essere nella
lista delle clausole throws di ciascun metodo che
possa lanciare l’eccezione o propagarla
 La clausola throws deve essere dichiarata
nell’intestazione del metodo
 Il compilatore segnala se un’eccezione controllata
non viene gestita propriamente

Eccezioni non controllate
 Non richiedono una gestione esplicita con la
clausola throws
 L’eccezioni non controllate in Java sono
quelle che si verificano a run time
 Discendono da RuntimeException o da
una sua classe discendente
 Tutte le altre sono controllate

Errori
 Gli errori sono simili alle eccezioni
RuntimeException o ai suoi discendenti
– Gli errori non devono essere controllati
– Gli errori non richiedono una clausola throws

La gerarchia di classe delle eccezioni
Object
Throwable
Error
Exception
LinkageError
Virtual MachineError
AWTError
RuntimeException
ClassNotFoundException
NullPointerException
IndexOutOfBoundException
ArthemticException
NoSuchMethodException
Eccezioni non controllate

Nuove definizioni d’eccezione
 Tutte le nuove classi che estenono la
gerarchia precedente o
– Discendono da RuntimeException e quindi
non sono controllate o
– Disecendono da Exception e quindi sono
controllate
 I metodi che le lanciano dovranno dichiararlo
nell’intestazione con la clausola throws
 Un metodo che può lanciare un’eccezione controllata
dovrà dichiararlo

Propagazione e gestione dell’eccezioni
controllate
 Un metodo che può sollevare un eccezione
controllata deve dichiararlo con la clausola
throws
 A sua volta un metodo che lo richiama deve
intercettarla o dichiararla, cioè deve:
– Gestire l’eccezione con la coppia try-catch o
– Dichiarare a sua volta che potrà sollevare
l’eccezione nella clausola throws

Il package java.awt
• Gestione dell’I/O orientato alla grafica: le finestre
• Sviluppo di interfacce utente grafiche indipendenti dalla
piattaforma:
astrazione delle caratteristiche comuni
• Le classi di java.awt:
- contenitori
- controlli
- gestori di layout

Concetti fondamentali sulle finestre
-AWT definisce una gerarchia di classi di finestre in cui ogni livello
prevede una maggiore funzionalità e specificità.
- Le classi di finestre più comuni sono Panel e Frame
-In cima alla gerarchia delle classi di AWT si trova la classe
Component, che incapsula tutti gli atributi di un componente visivo:
tutti gli elementi di interfaccia utente che compaiono sullo schermo sono
derivati da sottoclassi di Component

Gerarchia delle classi AWT
Component
Window
Container
Panel
Frame
TextField
TextArea
Checkbox
Scrollbar
List
Label
Dialog
Button
Canvas
FileDialog

Metodi di (ri)visualizzazione
public void paint(Graphics g)
visualizza il contenuto della finestra all’interno dell’ambiente
grafico g
void repaint( )
fa in modo che l’ambiente run-time esegua una chiamata di
update( ), che a sua volta chiama paint( )
void show( )
visualizza la finestra
void hide( )
nasconde la finestra

JAVA e Internet: documenti attivi
DOCUMENTI
Server
elementi passivi
elementi attivi:
Applet
Client
SICUREZZA + PORTABILITA’
Bytecode e sistema run-time

Applet
• Piccola applicazione con limitato accesso alle risorse del client
• Legame con HTML: il tag Applet per eseguire applet JAVA
• Accesso via Internet, istallazione ed esecuzione automatica come parte
di un documento web
• Struttura differente rispetto alle normali applicazioni
• Eredità da Panel: una Applet è una finestra che esegue codice
import java.awt.*;
import java.applet.*;
class AppletHelloWorld extends Applet {
public void paint(Graphics g) {
g.drawString(“Hello, www world”, 20, 20);
}
}

Esecuzione di Applet
• Visualizzatore di applet: Appletviewer (fornito con JDK)
• Browser web JAVA-compatibile (HotJava, Netscape Communicator, etc.)
• Documenti HTML con tag applet per lanciare l’esecuzione
<applet code = “HelloWorldRivisitato” width=200 height=60 >
</applet>
• Le applet non hanno bisogno di main
• Interfaccia grafica fornita da AWT
• Esecuzione event-driven: risposta rapida agli eventi e restituzione del
controllo

Ciclo di vita di un’applet
SISTEMA RUN-TIME
init
start
stop
destroy
caricamento
visita o
Rivisita della pagina
passaggio
ad altre
pagine
uscita

Struttura di un’applet
Generalmente si realizza un’applet estendendo la classe Applet e
ridefinendo i metodi:
in Applet
init( )
start( )
stop( )
destroy( )
in Component
paint( )
update( )

Scheletro di un’applet
import java.awt.*; // SCHELETRO DI UNA APPLET
import java.applet.*;
/* <applet code=“AppletSkel” width=300 heigth=100 >
</applet>
*/
public class AppletSkel extends Applet {
public void init( ) { // chiamato sempre per primo
// operazioni di inizializzazione
}
public void start( ) { // chiamato ogni volta che l’applet (ri)parte
// parte o riparte l’esecuzione
}
public void stop( ) { // chiamato quando l’applet viene bloccata
// operazioni per sospendere l’esecuzione
}
public void destroy( ) { // ultimo chiamato: l’applet termina
// operazioni terminali
}
public void paint(Graphics g ) { // chiamato per visualizzare l’applet
// mostra il contenuto della finestra
}
}

Metodi della classe Applet
• Metodi relativi ai comandi HTML
URL getCodeBase( ) rest. l’URL dell’applet
URL getDocumentBase( ) rest. l’URL del documento HTML che l’ha chiamata
String getParameter(String nomePar) rest. il parametro associato a nomePar
• Metodi per caricare/eseguire video e audio
AudioClip getAudioClip(URL url) rest. un oggetto che incapsula un brano
Image getImage(URL url) rest. un oggetto che incapsula un’immagine
void play(URL url) esegue il brano
• Metodi relativi all’Applet
void showStatus(String str) mostra una stringa nella barra di stato del browser
void resize(Dimension dim) ridimensiona l’applet secondo le dimensioni specif.
bool isActive( ) rest. true se l’applet è stata avviata, false se è stata arrestata

Pagine Web e Applets JAVA
• Le pagine web contengono oggetti multimediali (testo, video, suoni),
collegamenti ipertestuali, e applet
• I browser JAVA-compatibili consentono di caricare, verificare ed eseguire
applet JAVA
• Le librerie standard di JAVA forniscono supporto per le funzionalità
tipiche delle applet - Applet API (Application Programming Interface)
- Comunicare con altri computer su Internet (operazioni Tcp/Ip e URL)
- Elaborare grafica (operazioni di disegno e immagini sullo schermo )
- Gestire la GUI (manipolare finestre, bottoni, etc., tramite AWT)
- Eseguire effetti sonori

Inserire un’applet in una pagina web
<title>Arthur’s Home Page</title>
<h1>Welcome to my home page!</h1>
This page is still under construction
<p>
<applet code=JackhammerDuke.class
width=300 height=80>
</applet>
<address>avh@eng.sun.com</address>
Server
Client
File di
comandi
HTML
Internet
Web
browser

Specificare parametri per applet da HTML
• Personalizzare un’applet
• Modificarne gli aspetti
• Usarla in modi differenti
<title>Due Animazioni</title>
<h1>Two animations using the same applet</h1>
<p>
<applet code=ImageLoop.class width=80 height=80>
<param name=numImage value=10>
<param name=image value=duke>
<param name=pause value=100>
</applet>
<p>
<applet code=ImageLoop.class width=80 height=80>
<param name=numImage value=8>
<param name=image value=orologio>
<param name=pause value=100>
</applet>

Java Programming Language

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Java Programming Language

Semelhante a Java Programming Language (20)

Último

Último (11)

Java Programming Language

Notas do Editor