Programmare in Java
 Un esempio elementare
 Gli strumenti di Java
Struttura di un programma Java
 Metodi statici
 Variabili
 Tipi elementari
 Istruzioni principali

/****************************************************************/
1Il linguaggio Java
Formalismo ad alto livello...
 Permette di descrivere programmi basandosi su
concetti primitivi “sofisticati” (file, finestre, tabelle,
liste, ecc.)
...basato su una notazione testuale familiare
 Codice sorgente
 Simile, nella sintassi e nelle istruzioni al
linguaggio C

/****************************************************************/
2Codice Sorgente
 I programmi Java sono suddivisi in
“classi”
 Le classi sono descritte all'interno di file di
testo con estensione “.java”
 Ogni file contiene una sola classe
 Il nome file deve coincidere con il nome
della classe

/****************************************************************/
3Un esempio
Hello.java
public class Hello {
// Il programma più semplice
public static void main(String[] args) {
// Stampa un messaggio sul video
System.out.println(“Hello Java”);
}
}

/****************************************************************/
4Passi concettuali (1)
Scrittura
Compilazione
J
1001
0110
110..
.java .class
Codice
sorgente ByteCode

/****************************************************************/
5I passi concettuali (2)
Esecuzione
1001
0110
110..
.class
ByteCode

/****************************************************************/
6Gli strumenti di Java
La macchina virtuale
Il compilatore
Gli ambienti di sviluppo
La documentazione
Il debugger

/****************************************************************/
7Macchina virtuale (1)
Applicazione
tradizionale
Applicazione
Java
Macchina
Virtuale
Sistema Operativo
Hardware

/****************************************************************/
8Macchina virtuale (2)
Astrazione di un elaboratore “generico”
 Ambiente di esecuzione delle applicazioni Java
Esempio:
 java Hello
Responsabilità:
 Caricamento classi dal disco
 Verifica consistenza codice
 Esecuzione applicazione

/****************************************************************/
9Il compilatore
J
1001
0110
110..
Traduzione dei sorgenti testuali in
bytecode
 Linguaggio della macchina virtuale Java
Esempio:
javac Hello.java

/****************************************************************/
10Ambienti di sviluppo
Il codice sorgente Java è
composto da testo
 Un editor qualsiasi è sufficiente
Si possono usare ambienti integrati per lo
sviluppo (IDE)
 Offrono strumenti per la redazione, la
compilazione, l'esecuzione e la ricerca degli
errori

/****************************************************************/
11Esempi
Eclipse
 http://www.eclipse.org
JCreator
 http://www.jcreator.com
BlueJ
 http://www.bluej.org

/****************************************************************/
12Documentazione (1)
Strumento necessario
alla sopravvivenza del programmatore
Java!!
Raccolta di informazioni relative alle
classi appartenenti alle librerie standard
di Java
 http://java.sun.com/docs/

/****************************************************************/
13Documentazione (2)
Per ogni classe:
 Descrizione funzionale
 Elenco di attributi:
funzionalità, caratteristiche
 Elenco dei metodi:
funzionalità, parametri in ingresso, valori di
ritorno, ...

/****************************************************************/
14Il debugger
Strumento ausiliario
al programmatore
 Monitorare l'esecuzione
di una applicazione
 Analisi dei valori assunti dalle variabili, i metodi
della classe, ...
Comando jdb.exe

/****************************************************************/
15Dove si usa Java?
Apparati
di rete
Cellulari e
PC palmari
PC client
Server

/****************************************************************/
Elettrodomestici
16Java nei sistemi Client
Vantaggi
 Facilità di realizzazione delle interfacce grafiche
 Indipendenza dalla piattaforma di sviluppo e di
utilizzo
 Ciclo di sviluppo rapido
 Distribuzione immediata, a richiesta, tramite web
Svantaggi
 Prestazioni limitate rispetto ad applicazioni native
 Ambienti di esecuzione in forte evoluzione
Oggetto di questo corso

/****************************************************************/
17Java nei sistemi Server
Varie tipologie di utilizzo:
 Servlet / Java Server Pages / Java Server Faces
 EnterpriseJavaBean
 Application server
È il contesto in cui Java sta ottenendo il
massimo successo
Oggetto del corso “Programmazione in
ambienti distribuiti”

/****************************************************************/
18Java nei sistemi Embedded
Segmento di mercato in forte crescita:
 Milioni di PC connessi ad Internet
 Centinaia di milioni di telefoni cellulari
 Miliardi di elettrodomestici
Vengono usate librerie specifiche
 JavaCard, Java Micro Edition, ...

/****************************************************************/
19Installare Java (1)
Java Software
Development KIT
(J2SE SDK)
 Versione utilizzata nel corso 1.8.x
 Disponibile gratuitamente: oracle.com
 compilatore, librerie standard, macchina virtuale, ...

/****************************************************************/
20Installare Java (2)
Necessario modificare la variabile
d'ambiente
 PATH= ... ;/bin
 per invocare i comandi java (compilatore,
macchina virtuale, debugger, ...)
In Windows 2000/XP
 Pannello di controllo 
Sistema  Avanzate 
Variabili d'ambiente

/****************************************************************/
21Programmi Java
Java è un linguaggio ad oggetti
 L'unità minima di programmazione è la classe
 Un programma Java utilizza una o più classi
Per ora, consideriamo programmi formati da
una sola classe
 Un solo file sorgente
 Il nome del file coincide con il nome della classe
 L'estensione del file è “.java”

/****************************************************************/
24Formato generale
Prova.java
public class Prova {
/*
qui vengono riportati attributi e
metodi della classe
...
*/
}
Stesso nome!

/****************************************************************/
25main(...): la porta
sul mondo Java
public static void
main(String[] args){
/* istruzioni ... */
}
Punto di ingresso di ogni applicazione
 Invocato automaticamente dalla VM Java

/****************************************************************/
26Metodi statici
Sequenze di istruzioni che svolgono un
determinato compito
 Hanno un nome
 Possono avere dei parametri
 Possono ritornare un valore
 Dovrebbero avere un commento!

/****************************************************************/
27public class Test {
static int m1(int a, int b) {
int c = a*a+b*b;
return c;
}
public static
void main(String[] args) {
int i = m1(3,4);
System.out.println(i);
}
}

/****************************************************************/
28Commenti
Servono a documentare un programma
(o una sua parte)
 Racchiusi da “/*” e “*/”
 “//” inizia un commento che termina a fine riga
Usati sempre troppo poco!

/****************************************************************/
29Variabili locali
I metodi possono utilizzare variabili:
 Servono a memorizzare
risultati intermedi
 Dichiarate nel corpo del metodo
 Durata temporanea: quando il metodo ritorna, la
variabile è distrutta

/****************************************************************/
30Tipi: una forma per i dati
Variabili, parametri,
valori ritornati hanno
un tipo che ne precisa
/limita l'uso
 Possono contenere solo valori conformi al
proprio tipo
Esistono tipi
 Semplici (primitivi)
 Composti (classi) – descritti nelle lezioni
successive

/****************************************************************/
31Tipi primitivi
Numerici interi
 byte, short, int, long
Numerici reali
 float, double
Non numerici
 boolean, char

/****************************************************************/
32Tipi numerici interi (1)
Valori ammissibili
byte {-128 ... 127}
short {-32768 ... 32767}
int {-2147483648 ... 2147483647}
long {-9.22 E18 ... 9.22E18}

/****************************************************************/
33Tipi numerici interi (2)
Operazioni consentite
aritmetiche
+, -, *, /, %, ++, --, >>
logiche (bit a bit)
^, &, |, ~, <<, >>>
confronto
==, !=, >, >=, <, <=

/****************************************************************/
34Tipi numerici reali
Valori
 float {±3.403E38}
6 cifre significative
 double {±1.798E308}
15 cifre significative
Operazioni
 aritmetiche (+, -, *, /)
 confronto (==, !=,
>, >=, <, <=)

/****************************************************************/
35Tipi non numerici: boolean
Valori
 {false, true}
Operazioni
 logiche (&&, ||, !)
 confronto (==, !=)

/****************************************************************/
36Tipi non numerici: char
Rappresentazione
dei caratteri secondo
lo standard Unicode
 Lettere di vari alfabeti
arabo, armeno, bengalese, cirillico,
greco, latino, ...
 Simboli
diacritici, punteggiatura,
matematici, tecnici, ...

/****************************************************************/
37Tipi non numerici: char
Rappresentazione su due byte
 Le costanti sono indicate tra apici semplici (‘a')
 I valori non stampabili sono rappresentati nel
formato unicode (‘\u27AF')
Operazioni
 confronto
(==, !=, >,>=, <, <=)

/****************************************************************/
38Dichiarazioni
Introducono l'utilizzo di una variabile
Formato generale
‘;'
‘=' ‘;'
Esempi
 char c;
 int i = 10;
 long l1, l2;
Opzionale
La mancata dichiarazione è un errore
sintattico

/****************************************************************/
39Usare le variabili (1)
Si può dichiarare una variabile ovunque nel
codice di un metodo
 Bisogna farlo, però, prima di usarla
 Visibilità limitata al blocco di istruzioni in cui è
dichiarata
Le variabili devono essere inizializzate!
 int a;
Errore!
La variabile “a” non è stata
 int b = a;
inizializzata, e il suo valore
è casuale

/****************************************************************/
40Usare le variabili (2)
Ad una variabile può essere assegnato:
 Un valore costante
 Il risultato di una formula
Esempi
 int i = 1, j = 5;
 i = (5*j) % 10;
 long l = 10L;
 char c1 = ‘a', c2 = ‘\u0062';
 boolean b = false;

/****************************************************************/
41

Modellare la realtà
Le classi: il modello
 Attributi e metodi
Gli oggetti: il mattone
 Costruzione e accesso
 Riferimenti
 Ciclo di vita degli oggetti

/****************************************************************/
42Convenzioni sui nomi
Le classi hanno nomi che iniziano con la
lettera maiuscola
Metodi, attributi e variabili hanno l'iniziale
minuscola
 Se un nome è composto da più parole
giustapposte, l'iniziale di ogni parola successiva
alla prima è maiuscola
 int contatoreNumeroOccorrenze = 0;
 class CentraleTelefonica { }

/****************************************************************/
43Modellare la realtà (1)
STATO
via1: verde
via2: rosso
STATO
motore:acceso
velocità: 0 COMPORTAMENTO
Parti!
Frena!
Sterza!

/****************************************************************/
44Modellare la realtà (2)
Stato
 L'insieme dei parametri caratteristici che
contraddistinguono un oggetto in un dato istante
 Modellato come insieme di attributi
Comportamento
 Descrive come si modifica lo stato a fronte degli
stimoli provenienti dal mondo esterno
 Modellato come insieme di metodi

/****************************************************************/
45Classi
La classe costituisce il “progetto” di un
oggetto
 Specifica gli attributi
 Descrive i metodi
 Indica lo stato iniziale
Ogni classe ha un nome
 Deve essere univoco

/****************************************************************/
46Oggetti
Data una classe, è possibile costruire uno o
più oggetti
 Gli oggetti vengono detti “istanze” della classe
 In Java si utilizza la notazione
new NomeClasse ( );
Ogni oggetto “vive” all'interno della memoria
del calcolatore
 Qui viene memorizzato il suo stato
 Oggetti differenti occupano posizioni differenti

/****************************************************************/
47Oggetti
class Cerchio {
Cerchio
r: double
...
Memoria
double r;
...
r:??
}
new
Cerchio()

/****************************************************************/
48Stato di un oggetto
Ogni oggetto ha un proprio stato:
 Insieme dei valori assunti dagli attributi
dell'oggetto
 Operando sui metodi, si può modificare lo stato
All'atto della costruzione di un oggetto,
occorre assegnare un valore ai diversi
attributi
 È il compito di un metodo particolare, detto
costruttore

/****************************************************************/
49Costruttore
Metodo che inizializza gli attributi di una
classe
Sintassi particolare:
 Ha lo stesso nome della classe
 Non indica nessun tipo ritornato
class Cerchio {
double r;
Cerchio() {
r=1.0;
}
}

/****************************************************************/
50Costruire oggetti
class Cerchio {
double r;
Cerchio() {
r=1.0;
}
...
}

/****************************************************************/
Cerchio
r: double
...
Memoria
r:1.0
new
Cerchio()
51Rettangolo
Costruire oggetti
class Rettangolo {
double b,h;
Rettangolo() {
b=2.0;
h=1.0;
} ...
}

/****************************************************************/
b: double
h: double
...
Memoria
r:1.0
b:2.0
h:1.0
new
Rettangolo()
52Costruttore e parametri
Normalmente un costruttore assegna valori
“standard” agli attributi
Se ha dei parametri, può differenziare gli
oggetti costruiti
 Chi invoca il costruttore deve fornire
i parametri richiesti
Una classe può avere molti costruttori
 Occorre che siano distinguibili attraverso il
numero ed il tipo di parametri richiesti

/****************************************************************/
53Costruttore e parametri
class Poligono {
double lato;
int numeroLati;
Poligono(int n) {
numeroLati=n;
lato=1.0;
}
Poligono p;
}
p= new Poligono(3);

/****************************************************************/
54Riferimenti
Si opera su un oggetto attraverso un
riferimento
 Indica la posizione in memoria occupata
dall'oggetto
All'atto della costruzione, l'operatore new:
 Alloca un blocco di memoria sufficiente a
contenere l'oggetto
 Invoca il costruttore, determinandone la corretta
inizializzazione
 Restituisce il riferimento (indirizzo) del blocco
inizializzato

/****************************************************************/
55Riferimenti
new Cerchio();
new Rettangolo();
Riferimento al
cerchio
Riferimento al
rettangolo
Memoria
r:1.0
b:2.0
h:1.0
Gli oggetti vengono costruiti,
ma dove finisce il loro riferimento?

/****************************************************************/
56Variabili
I riferimenti possono essere memorizzati
all'interno di variabili locali
 Devono avere un tipo compatibile con il tipo di
riferimento che si intende memorizzare al loro
interno
 Devono essere dichiarate prima di essere usate
{...
Cerchio c;
c= new Cerchio();
...}

/****************************************************************/
57Variabili
{
Cerchio c;
c= new Cerchio();
}
Memoria
r:1.0
c

/****************************************************************/
58Variabili
{
Cerchio c;
c= new Cerchio();
}
Memoria
r:1.0
c

/****************************************************************/
59Ciclo di vita
delle variabili locali
Le variabili locali “esistono” finché il metodo
(blocco di codice) che le definisce è in
esecuzione
 Quando si incontra la loro definizione, il sistema
riserva un'area di memoria per ospitarne il
contenuto
 Quando il metodo (blocco) termina, l'area viene
rilasciata ed il contenuto della variabile perso
 La memoria viene prelevata da una zona
apposita detta “stack” (quella in cui si trovano gli
oggetti, invece, si chiama “heap”)

/****************************************************************/
60Ciclo di vita
delle variabili locali
{
Cerchio c;
c= new Cerchio();
}
Memoria
r:1.0
c

/****************************************************************/
61Riferimenti multipli
Uno stesso oggetto può essere denotato da
più variabili
 Succede quando si assegna ad un variabile il
valore contenuto in un'altra variabile
 Le variabili condividono il riferimento allo stesso
oggetto
Se si opera sull'oggetto attraverso la prima
variabile, le modifiche sono visibili da tutte le
altre variabili coinvolte

/****************************************************************/
62Riferimenti multipli
Cerchio c1,c2;
c1= new Cerchio();
c2= c1;
Memoria
r:1.0
c1
c2

/****************************************************************/
63Variabili elementari
Non tutte le variabili contengono un
riferimento
 Le informazioni più semplici possono essere
memorizzate direttamente nella variabile
 È il caso delle variabili il cui tipo è elementare
(detto anche primitivo)

/****************************************************************/
64Variabili elementari
int i;
i= 3;
Memoria
i

/****************************************************************/
65Variabili elementari
Memoria
int i;
i= 3;
i
3

/****************************************************************/
66Copia di variabili
elementari
Se si assegna ad una variabile elementare il
valore di un'altra variabile viene eseguita
una copia del valore
 I due valori diventano disgiunti e potranno
evolvere indipendentemente

/****************************************************************/
67Variabili elementari
Memoria
int i, j;
i= 3;
j= i;
i 3
j 3

/****************************************************************/
68Riferimenti nulli
Nel caso di variabili di tipo classe, a volte
occorre indicare che non contengono
nessun valore
 Si usa la parola chiave null
Se una variabile vale null, non è possibile
accedere ai metodi o agli attributi

/****************************************************************/
69Riferimenti nulli
Cerchio c;
c= new Cerchio();
...
c=null
Memoria
r:1.0
c

/****************************************************************/
70Riferimenti nulli
Cerchio c;
c= new Cerchio();
...
c=null
Memoria
r:1.0
c

/****************************************************************/
71Accedere agli oggetti
 Noto il riferimento ad un oggetto, è possibile
invocarne i metodi
 Si usa la notazione
variabile.metodo(...);
 Nelle parentesi si indicano gli eventuali parametri
 Se la variabile contiene un riferimento nullo si
genera un errore di esecuzione
 Il metodo è costituito da un insieme di istruzioni
 Il comportamento è simile ad una chiamata a procedura
 Il chiamante attende il completamento del metodo, poi
prosegue la propria elaborazione

/****************************************************************/
72Parametri
 Un metodo può avere parametri
 Internamente, appaiono come variabili locali
 Il loro valore, però, è fornito dal chiamante
 Come le variabili, i parametri hanno un tipo
 Elementare
 Complesso
 Nel caso di parametri di tipo elementare
 All'interno del parametro viene memorizzata una copia del
valore indicato dal chiamante
 Eventuali modifiche compiute dal metodo sul valore non si
ripercuotono sul chiamante
 Se il tipo è complesso
 Il parametro contiene una copia del riferimento all'oggetto
passato come parametro
 Le eventuali modifiche sullo stato dell'oggetto sono visibili
al chiamante

/****************************************************************/
73Invocare metodi
Cerchio c;
c= new Cerchio();
c.setRaggio(2.0);
Memoria
r:1.0
r:2.0
c

/****************************************************************/
74Valori di ritorno
 Alcuni metodi restituiscono un valore
 Il tipo del valore ritornato viene dichiarato prima del nome
del metodo
 double calcolaPerimetro() { ... }
 Il valore ritornato può essere assegnato ad una
variabile
 Occorre che la variabile sia compatibile con il tipo del
valore ritornato
 Altri metodi non ritornano nulla
 In questo caso dichiarano di ritornare il tipo predefinito void
 void setRaggio(double r) { ... }

/****************************************************************/
75Valori di ritorno
c.setRaggio(2.0);
double p;
p=c.calcolaPerimetro()
Memoria
r:1.0
r:2.0
p
c

/****************************************************************/
76Valori di ritorno
c.setRaggio(2.0);
double p;
p=c.calcolaPerimetro()
Memoria
r:1.0
r:2.0
p
12.56
c

/****************************************************************/
77Tipologie di metodi
Un metodo, in generale, può operare
liberamente sull'oggetto su cui viene
invocato...
 Modificandone lo stato
 Invocando metodi su altri oggetti conosciuti
 Effettuando calcoli
 Restituendo risultati
Spesso, però, si progettano metodi
specializzati in una delle funzioni citate

/****************************************************************/
78Tipologie di metodi
 Modificatori (mutator)
 Servono ad alterare, in modo controllato, lo stato
dell'oggetto (o una sua parte specifica)
 Di solito hanno parametri e non ritornano nulla
 Per convenzione, in Java, hanno un nome simile a
void setXyz(...);
 Lettori (accessor)
 Permettono di conoscere lo stato (o una sua parte
specifca) di un oggetto
 Di solito, non hanno parametri, e ritornano il valore letto
 Per convenzione, in Java, hanno un nome simile a
getXyz();

/****************************************************************/
79Attributi
Come le variabili, anche gli attributi possono
avere tipi
 Elementari
 Complessi (riferimenti ad oggetti)
Un attributo di tipo elementare
 Contiene direttamente il valore
Un attributo di tipo complesso
 Contiene il riferimento ad un oggetto (oppure
null)

/****************************************************************/
80Esempio
class Disegno{
int x;
int y;
}
Cerchio c;
...

/****************************************************************/
Tipo elementare
Tipo composto
81Attributi e costruttore
All'atto dell'invocazione del costruttore, tutti
gli attributi hanno un valore di default
 Gli attributi semplici valgono 0 (false, nel caso dei
valori booleani)
 Quelli complessi, valgono null
È compito del costruttore assegnare valori
opportuni se quelli di default non sono adatti
 Questo può comportare anche la creazione di
oggetti

/****************************************************************/
82Disegno
Attributi e costruttore
class Disegno {
double x,y;
Cerchio c;
Disegno() {
x=7.0;
y=3.0;
c= new Cerchio()
}
...
}

/****************************************************************/
x, y: double
c: Cerchio
...
Memoria
x:0
7
y:0
c:
83Disegno
Attributi e costruttore
class Disegno {
double x,y;
Cerchio c;
Disegno() {
x=7.0;
y=3.0;
c= new Cerchio()
}
...
}

/****************************************************************/
x, y: double
c: Cerchio
...
Memoria
x:7
y:0
3
c:
84Disegno
Attributi e costruttore
class Disegno {
double x,y;
Cerchio c;
Disegno() {
x=7.0;
y=3.0;
c= new Cerchio()
}
...
}

/****************************************************************/
x, y: double
c: Cerchio
...
Memoria
r:1.0
x:7
y:0
c:
85Ciclo di vita di un oggetto
L'operatore new, su richiesta del
programmatore, alloca la memoria
necessaria a contenere un oggetto
 D1: quando viene rilasciata?
 R1: quando l'oggetto non serve più!
 D2: chi decide che non serve più?
 R2: l'ambiente di esecuzione (!?!)

/****************************************************************/
86Accessibilità
Un oggetto è accessibile fino a che ne esiste
un riferimento
Nel momento in cui non esistano più
riferimenti, l'oggetto può essere eliminato
 Rilasciando la memoria che occupa
I riferimenti sono memorizzati in variabili e
attributi
 Si cancellano quando la variabile cessa di
esistere (fine del blocco)
 Oppure assegnando esplicitamente il valore null

/****************************************************************/
87Riferimenti nulli
Cerchio c;
c= new Cerchio();
...
c=null;
Memoria
r:1.0
c

/****************************************************************/
88Conteggio dei riferimenti
 All'interno di ogni oggetto, Java mantiene un
contatore nascosto
 Indica il numero di riferimenti esistenti a quello specifico
oggetto
 Quando il suo valore scende a 0, indica che l'oggetto può
essere eliminato, rilasciando la memoria che occupa
 Un particolare sottosistema, il garbage collector, si
occupa, periodicamente, di riciclare la memoria
degli oggetti eliminati
 Viene eseguito automaticamente dalla macchina virtuale
Java

/****************************************************************/
89Conteggio dei riferimenti
Cerchio c1,c2;
c1= new Cerchio();
c2=c1;
Memoria
1
r:1.0
c1
c2

/****************************************************************/
90Conteggio dei riferimenti
Cerchio c1,c2;
c1= new Cerchio();
c2=c1;
Memoria
2
1
r:1.0
c1
c2

/****************************************************************/
91Conteggio dei riferimenti
...
c2= null;
...
Memoria
2
1
r:1.0
c1
c2

/****************************************************************/
92Conteggio dei riferimenti
...
c1= null;
...
Memoria
1
r:1.0
c1

/****************************************************************/
93Costrutti di programmazione
Istruzioni semplici
 Scelta
 Ripetizione
 Salto strutturato
Invocazione di metodi
 Trattata più in dettaglio
successivamente
Blocchi di istruzioni
 Racchiusi tra parentesi
graffe {...}

/****************************************************************/
94Istruzioni di scelta (1)
if ( condizione )...
if ( condizione )... else ...
Verifica della condizione
 Vera si esegue l'istruzione o il blocco di istruzioni
successivo
 Falsa si salta all'istruzione successiva oppure
viene eseguito il blocco “else”

/****************************************************************/
95Istruzioni di scelta (2)
switch (var) {
case val1: ... break;
case valN: ... break;
default: ...
}
Struttura di selezione multipla
 Valutazione del valore di una variabile
 val1, ..., valN:
espressioni costanti (interi o caratteri)

/****************************************************************/
96Istruzioni di ripetizione (1)
for( espr1 ; espr2 ; espr3 ){
... //istruzioni da ripetere
}
 espr1: inizializzazione variabile/i di controllo
 espr2: condizione di continuazione
 espr3: modifica della/e variabili di controllo

/****************************************************************/
97Istruzioni di ripetizione (2)
while ( cond ){ do {
...
...
}
} while( cond );
Esecuzione di un blocco di istruzioni finché la
condizione rimane vera
do/while garantisce almeno una iterazione

/****************************************************************/
98Salto strutturato
Istruzioni che permettono di alterare il flusso
di esecuzione:
 break : provoca l'uscita immediata dal blocco
 continue: salto delle rimanenti istruzioni del
blocco, procede con l'interazione successiva del
ciclo
 Usati nei costrutti while, do/while, for,
switch (quest'ultimo, solo break)

/****************************************************************/
99Oggetti e utilizzatori
 Non tutte le caratteristiche di un oggetto
devono essere visibili dall'esterno
 Rischio di manomissioni indebite
 Occorre separare l'interfaccia
dall'implementazione
 Si realizza l'incapsulamento utilizzando un
modificatore di visibilità
 Metodi e attributi possono preceduti da una
parola chiave che indica il livello di privilegio
loro associato

/****************************************************************/
100Modificatori di visibilità
Private
 Indica che si può accedere all'elemento solo da
altri metodi appartenenti alla stessa classe
Public
 Indica che l'elemento può essere utilizzato da
metodi di qualsiasi classe
[Nulla]
 In assenza di indicazioni, l'elemento è
accessibile alle altre classi dello stesso
“gruppo” (package)

/****************************************************************/
101Visibilità delle classi
Anche le classi possono essere precedute
da un modificatore di visibilità
 In questo caso, “private” non ha senso
Se una classe è dichiarata pubblica, può
essere utilizzata da classi appartenenti a
qualsiasi gruppo (package)
 Altrimenti, può essere usata solo nell'ambito del
gruppo in cui è stata definita

/****************************************************************/
102Incapsulamento
Per massimizzare il riuso, solo
l'informazione minima necessaria al
funzionamento deve essere accessibile
Di solito:
 Attributi privati
 Metodi pubblici
 Costruttori pubblici

/****************************************************************/
103Incapsulamento
public class Cerchio {
private double r;
public Cerchio() {
...
}
public void setRaggio(double val)
{
r=val;
}
}

/****************************************************************/
104Metodi e attributi statici
Oggetti appartenenti ad una stessa classe
hanno lo stesso insieme di attributi
 Ogni oggetto ha però i propri valori, indipendenti
dagli altri
 Un metodo opera sui valori dell'oggetto su cui è
invocato
 L'evoluzione dello stato di un oggetto è
indipendente da quella di altri oggetti della stessa
classe

/****************************************************************/
105Attributi statici
 Talora, si vuole memorizzare
un'informazione comune a tutti gli oggetti di
una data classe
 Si utilizzano gli attributi “statici”
 Il loro valore viene conservato in un blocco di
memoria separato, relativo alla classe
 Sono analoghi a variabili globali in altri
linguaggi (C, C++)

/****************************************************************/
106Esempio
class Cerchio {
static double pi=3.14;
double r;
...
}

/****************************************************************/
Memoria
pi:3.14
107Esempio
Cerchio c1=
new Cerchio(1.0);
Cerchio c2=
new Cerchio(2.5);
Memoria
pi:3.14
r:1.0
r:2.5

/****************************************************************/
108Esempio
class Cerchio {
...
double calcolaArea() {
double a;
a = r*r*pi;
return a;
}
}

/****************************************************************/
109Uso degli attributi statici
Si può fare accesso ad un attributo statico
anche in mancanza di un oggetto specifico
 double d= Cerchio.pi/2;
Gli attributi statici devono essere inizializzati
 Non si può fare nel costruttore!
 Occorre farlo all'atto della dichiarazione
 static double pi = 3.14 ;

/****************************************************************/
110Metodi statici
 Non fanno riferimento a nessun attributo
specifico di un oggetto
 Preceduti dal modificatore “static”
 Equivalenti a procedure e funzioni di altri
linguaggi
 Possono essere invocati a partire dal nome
della classe

/****************************************************************/
111Esempi
La classe “Math” contiene metodi statici per
le principali operazioni matematiche
 double d1,d2;
 d1 = Math.sqrt( 2.0 );
 d2 = Math.sin( Math.PI / 2.0 );
La classe “System” contiene, sotto forma di
attributi statici, oggetti che modellano le
interazioni con la console di sistema
 System.out
 System.in

/****************************************************************/
//output su schermo
//input da tastiera
112System.out
public
void print(...)
PrintStream
public
void println(...)

/****************************************************************/
113System.in
public
InputStream
int read()
Restituisce il codice
ASCII del tasto
successivo!

/****************************************************************/
114Il metodo main()
 Quando un programma inizia, non può
esistere ancora nessun oggetto
 Il punto di ingresso deve essere un metodo
statico e pubblico
 Perché?
 Convenzione Java:
 public static void
main(String[ ] args)

/****************************************************************/
115Esempio
public class Hello {
public static void
main(String[] args) {
System.out.println(“Hello Java”);
}
}

/****************************************************************/
116La classe String
 Classe che modella sequenze immutabili
di caratteri
 Sintassi semplificata
 String s1= “Hello” ;
 String s2 = s1+ “ Java”
 Offre molti metodi
 Confronto, ricerca, derivazione di nuove
stringhe, informazioni generali, ...

/****************************************************************/
117Confronto e ricerca
 public boolean equals(String s)
 Restituisce true se il parametro contiene gli
stessi caratteri dell'oggetto corrente
 public boolean equalsIgnoreCase(String s)
 Idem, trascurando la differenza tra maiuscole e
minuscole
 public int indexOf(String s)
 Restituisce la posizione, all'interno della
sequenza di caratteri, in cui inizia la stringa
indicata come parametro (-1 se non esiste)

/****************************************************************/
118Derivazione e informazioni
 public String toUpperCase()
 Restituisce una nuova stringa contenente gli stessi
caratteri in versione maiuscola
 public String replace(char oldChar, char newChar)
 Restituisce una nuova stringa in cui tutte le occorrenze
di oldChar sono sostituite con newChar
 public String substring(int beginIndex, int
endIndex)
 Restituisce una nuova stringa formata dai caratteri che
iniziano alla posizione beginIndex fino a endIndex
escluso
 public int length()
 Restituisce la lunghezza in caratteri della stringa
corrente

/****************************************************************/
119Esempi
String s1=“ciao”;
String s2= s1.toUpperCase();
boolean b= s2.equals (s1);
int i= s2.length();
int j= s2.indexOf(“AO”);
String s3=s1.substring(j,i);
char c=s1.charAt(0);

/****************************************************************/
120

Raggruppare le classi
in package
Struttura dei package
delle API Java
Il package
java.lang

/****************************************************************/
121Nomi delle classi
La metodologia ad oggetti favorisce il riuso
delle classi
 Il nome della classe dovrebbe suggerirne la
semantica
 A volte bisogna utilizzare nello stesso progetto
classi già esistenti, di provenienza diversa ed
aventi lo stesso nome
 Occorre poter differenziare ulteriormente tali
classi

/****************************************************************/
122Package:
un cognome per le classi
Le classi possono essere raggruppate in
“package”
 Ogni package ha un nome
 Viene scelto in modo da essere univoco
Una classe è denotata:
 Dal nome proprio
 Dal package di appartenenza

/****************************************************************/
123Package: appartenenza
 Le classi che appartengono ad uno stesso
package formano un gruppo
 Come nel caso di una famiglia, c'è un
rapporto privilegiato:
 Accessibilità a tutti i componenti non privati
(public, protected, )

/****************************************************************/
124Il nome dei package
 Sequenza di parole separate da ‘.'
 Dovrebbe suggerire lo scopo comune del
gruppo di classi
 Per evitare collisioni, spesso inizia con il nome
DNS in ordine inverso
 it.polito.didattica.esempi

/****************************************************************/
125Sintassi
La parola chiave “package” denota il gruppo
di appartenenza
 È seguita dal nome del package
 Deve essere posta all'inizio del file sorgente

/****************************************************************/
126Sintassi
Le classi dello stesso package si
“conoscono”
 Basta usare il nome proprio della classe
Tra package diversi occorre usare il nome
completo
 Anche nei costruttori

/****************************************************************/
127Esempio
package forme; Cerchio.java
public class Cerchio {
//...
package prova;
}
class Esempio {
Esempio.java
forme.Cerchio c;
Esempio () {
c=new forme.Cerchio();
}
}

/****************************************************************/
128Importare riferimenti
 L'uso di nomi completi è scomodo
 Gli amici si chiamano per nome
 Il costrutto “import” permette di definire le
classi note
 Queste vengono indicate solo per nome
 Serve solo in fase di compilazione!

/****************************************************************/
129Esempio
package prova;
import forme.Cerchio;
Esempio.java
class Esempio {
Cerchio c;
Esempio () {
c=new Cerchio();
}
}

/****************************************************************/
130Importare riferimenti
 Si possono includere un numero qualsiasi
di clausole import
 Devono sempre precedere la definizione della
classe
 Per importare tutte le classi di un package,
si usa la sintassi
 import NomePackage.* ;

/****************************************************************/
131Gerarchia di package
 Il nome di un package può essere formato
da molti segmenti
 Package che condividono lo stesso prefisso,
possono avere funzionalità “collegate”
o java.awt
o java.awt.event
 Per Java, sono gruppi totalmente separati

/****************************************************************/
132Package anonimo
 Le classi che non dichiarano in modo
esplicito il proprio package appartengono al
package “anonimo”
 A partire dalla versione 1.4, le classi del
package anonimo non possono essere
utilizzate da classi appartenenti ad altri
package

/****************************************************************/
133Compilare ed eseguire
 Per poter utilizzare una classe
all'interno di un'altra non basta
“risolverne” il nome
 Occorre localizzare il codice ad essa
associato
 Altrimenti viene lanciato l'errore
“NoClassDefFoundError”

/****************************************************************/
134Rappresentazione su disco
Ad ogni classe, corrisponde un file “.class”
che contiene il codice eseguibile
 Questo deve risiedere in una (gerarchia di)
cartella il cui nome coincide con quello del
package
 Le classi del package anonimo si trovano nella
cartella radice

/****************************************************************/
135Rappresentazione su disco
public class Test {
//...
}
package geom.forme;
public class Cerchio {
//...
}
...
Test
.class
geom
forme
Cerchio
.class

/****************************************************************/
136La variabile CLASSPATH
Variabile d'ambiente del sistema operativo
 Specifica un insieme di cartelle radice in cui
cercare i file “.class” o le sottocartelle dei
package
 Può contenere direttori compressi (file “.jar”)
set CLASSPATH=
. ; c:\a.jar; c:\classes
Cerca i file .class, in ordine:
Nella cartella in cui viene eseguita la JVM (“.”)
Nella cartella compressa c:\a.jar
Nella cartella c:\classes

/****************************************************************/
137File Jar
Gerarchie di cartelle e file compressi
 Analoghi a file “.zip”
 Possono essere manipolati con il comando “jar”
Facilitano la distribuzione di interi package

/****************************************************************/
138API Java
Application Programming Interface
 Insieme di meccanismi per interagire con il
sistema ospitante
 Progettati interamente ad oggetti
Offrono
 Funzioni di libreria
 Interfaccia verso il sistema operativo
Versione 1.4.2:
 135 package
 Oltre 2700 classi

/****************************************************************/
139Package principali
 java.awt
 Abstract Windowing Toolkit
 Classi per creare interfacce utente di tipo
grafico
 java.io
 Input/Output
 Classi per accedere a a flussi di dati, file e altri
meccanismi di comunicazione

/****************************************************************/
140Package principali
java.lang
 Contiene le classi fondamentali del linguaggio
java.math
 Estensioni matematiche
 Classi per modellare numeri interi e reali con
precisione illimitata
java.net
 Meccanismi di accesso alla rete
 Socket, URL, connessioni HTTP, ...

/****************************************************************/
141Package principali
 java.nio
 New Input/Output
 Meccanismi di basso livello per interfacciarsi
con il mondo esterno
 java.security
 Classi che implementano il modello di
sicurezza di Java
 java.sql
 Accesso a basi dati relazionali

/****************************************************************/
142Package principali
java.text
 Trattamento multiculturale di numeri, date, testo
java.util
 Insieme variegato di classi ad uso generale

/****************************************************************/
143java.lang: l'ABC delle
applicazioni Java
 Fornisce le classi fondamentali
per la programmazione Java
 Importato automaticamente dal compilatore in
tutti i programmi
 Contiene – tra le altre – le classi
Object, Throwable, String

/****************************************************************/
144java.lang.StringBuffer
 Analoga alla classe String
 Ma permette di modificare i caratteri contenuti
 Principali operazioni




append(...)
insert(...)
replace(...)
toString()

/****************************************************************/
145Classi “wrapper”
Utilizzate per trasformare in oggetti dati
elementari
 Il dato contenuto è immutabile
Pattern generale
dell'ingegneria
del software
oggetto
risorsa
non ad oggetti

/****************************************************************/
146Classi “wrapper”
Object
Number
Byte
Integer
Short

/****************************************************************/
Long
Boolean
Char
Float
Double
147Wrapper numerici
 Sottoclassi di Number
 Metodi per
 Trasformare una stringa
in un numero e viceversa
 Trasformare un numero in formati diversi (con
possibile troncamento)
 Rappresentazione testuale ottale,
esadecimale, binaria

/****************************************************************/
148Character, Boolean
 Character




Maiuscolo / minuscolo
Valore Unicode
Confronto
...
 Boolean
 Conversione da/verso stringa
 Confronto
 ...

/****************************************************************/
149java.lang.System
 Contiene attributi e metodi statici, utilizzati
per:





Interazione con il sistema
Acquisizione di informazioni
Caricamento di librerie
Accesso a standard input e output
...
 Non può essere istanziata

/****************************************************************/
150System: i metodi (1)
 exit(...)
 terminazione della JVM
 currentTimeMillis()
 Numero di millisecondi trascorsi dal 1 gennaio
1970
 setProperties(...)/getProperties(...)
 assegnazione e acquisizione delle proprietà di
sistema

/****************************************************************/
151System: i metodi (2)
 gc()
 invocazione del garbage collector
 load(...) / loadLibrary(...)
 carica dinamicamente un file o una libreria
 setIn(...), setOut(...), setErr(...)
 riassegnazione dei flussi standard

/****************************************************************/
152java.lang.Math
 Mette a disposizione gli
strumenti necessari per le operazioni
matematiche base
 Contiene solo metodi e attributi statici
 valore assoluto, logaritmo, potenza,
trigonometrici, minimo, massimo, ...
 Math.pow(2,10); //2 10

/****************************************************************/
153java.lang.Runtime
 Singola istanza per ogni applicazione
 Consente di interfacciarsi con il sistema
operativo
 Metodi
 Alcuni analoghi a System: exit, gc, ...
 Esecuzione di un processo, memoria
disponibile,...

/****************************************************************/
154Array
All'interno di un programma può essere
necessario gestire collezioni di dati:
 Il modo più semplice per organizzarli, se sono di
tipo omogeneo, è attraverso il concetto di array o
vettore
Array in Java: oggetti che incapsulano
sequenze ordinate di dati
 Hanno dimensione fissa, definita all'atto della
creazione
 Sintassi semplificata per accedere ai singoli
elementi

/****************************************************************/
155int[] valori;
valori = new int[3];
for (int i=0; i< valori.length; i++)
valori[i]= i*i;
Memoria
length
3
0
0
0
valori

/****************************************************************/
156int[] valori;
valori = new int[3];
for (int i=0; i< valori.length; i++)
valori[i]= i*i;
Memoria
length
3
0
1
4
valori

/****************************************************************/
157Tipologie di array
Esistono due gruppi di array
 Quelli che modellano sequenze di tipi
elementari (interi, reali, caratteri, booleani)
 Quelli che modellano sequenze di oggetti
Qualunque sia il gruppo di appartenenza, gli
array sono sempre oggetti complessi
 Vengono creati tramite l'operatore new
 Si accede ad essi attraverso un riferimento in
memoria

/****************************************************************/
158Inizializzare un array
Nel caso di array di tipi elementari, all'atto
della creazione vengono assegnati valori di
default
 0 per i numeri (interi e reali)
 false per i valori logici
 ‘\000' per i caratteri
A volte si conosce a priori l'intero contenuto
dell'array
 Java offre una sintassi semplificata per la sua
inizializzazione
integer[] valori = new integer[]
{4, 0, 7, 9};

/****************************************************************/
159Uso degli array
 Per accedere ad un singolo elemento, si utilizza la
sintassi
 nome_array [ indice ]
 L'indice deve essere compreso tra 0 e il numero di
elementi presenti nell'array
 Un array può contenere anche tipi complessi
(oggetti)
 In questo caso, nelle singole posizioni sono memorizzati i
riferimenti agli oggetti specifici
 All'atto della creazione del vettore, tutti i riferimenti
contenuti valgono null
String[] nomi=
new String[10];

/****************************************************************/
160String[] nomi;
nomi = new String[3];
nomi[1]=“Mario”
Memoria
length
3
null
null
null
nomi

/****************************************************************/
161String[] nomi;
nomi = new String[3];
nomi[1]=“Mario”
Memoria
length
3
null
null
null
nomi

/****************************************************************/
“Mario”
162Array a più dimensioni
È anche possibile creare matrici
 int [ ] [ ] matrice= new int [3] [3];
Si tratta di “array di array”
 Il primo indice si riferisce alla riga, il secondo alla
colonna
Non c'è limite al numero di dimensioni
dell'array
 Se non la memoria disponibile...

/****************************************************************/
163int[][] matrice = new int[3][3];
matrice[2][0]= 1;
int[]
int[][]
matrice
length 3
null null null
int[]
length 3
int[]
3
length
0
0
length
0
0 3
1
0

/****************************************************************/
0
0
0
0
164

I concetti principali
Ereditarietà in Java
La classe Object
Classi astratte
e interfacce

/****************************************************************/
165Riusare il software
 A volte si incontrano classi con funzionalità simili
 In quanto sottendono concetti semanticamente “vicini”
 Una mountain bike assomiglia ad una bicicletta tradizionale
 È possibile creare classi disgiunte replicando le
porzione di stato/comportamento condivise
 L'approccio “Taglia&Incolla”, però, non è una strategia
vincente
 Difficoltà di manutenzione correttiva e perfettiva
 Meglio “specializzare” codice funzionante
 Sostituendo il minimo necessario

/****************************************************************/
166Ereditarietà
 Meccanismo per definire una nuova classe (classe
derivata) come specializzazione di un'altra (classe
base)
 La classe base modella un concetto generico
 La classe derivata modella un concetto più specifico
 La classe derivata:
 Dispone di tutte le funzionalità (attributi e metodi) di quella
base
 Può aggiungere funzionalità proprie
 Può ridefinirne il funzionamento di metodi esistenti
(polimorfismo)

/****************************************************************/
167Esempio
Bicicletta
coppia
rapportoPosteriore
...
pedala(coppia)
cambiaRapporto(n)
frena(intensità)
...
MountainBike
rapportoAnteriore
cambiaRapportoAnt(n)

/****************************************************************/
Tandem
coppia2
pedala2(coppia)
168Terminologia
Classe base,
superclasse
Bicicletta
MountainBike
Tandem
Classi derivate,
sottoclassi

/****************************************************************/
169Astrazione
 Il processo di analisi e progettazione del software di
solito procede per raffinamenti successivi
 Spesso capita che le similitudini tra classi non siano colte
inizialmente
 In una fase successiva, si coglie l'esigenza/opportunità di
introdurre un concetto più generico da cui derivare classi
specifiche
 Processo di astrazione
 Si introduce la superclasse che “astrae” il concetto comune
condiviso dalle diverse sottoclassi
 Le sottoclassi vengono “spogliate” delle funzionalità comuni
che migrano nella superclasse

/****************************************************************/
170Veicolo
double getVelocità()
double getAccelerazione()
...
Bicicletta
void pedala()

/****************************************************************/
Automobile
void avvia()
void spegni()
171Tipi ed ereditarietà
 Ogni classe definisce un tipo:
 Un oggetto, istanza di una sotto-classe, è formalmente
compatibile con il tipo della classe base
 Il contrario non è vero!
 Esempio
 Un'automobile è un veicolo
 Un veicolo non è (necessariamente) un'automobile
 La compatibilità diviene effettiva se
 I metodi ridefiniti nella sotto-classe rispettano la semantica
della superclasse
 L'ereditarietà gode delle proprietà transitiva
 Un tandem è un veicolo (poiché è una bicicletta, che a sua
volta è un veicolo)

/****************************************************************/
172Vantaggi dell'ereditarietà
Evitare la duplicazione
di codice
Permettere il riuso
di funzionalità
Semplificare la costruzione
di nuove classi
Facilitare la manutenzione
Garantire la consistenza delle interfacce

/****************************************************************/
173Ereditarietà in Java
Si definisce una classe derivata attraverso la
parola chiave “extends”
 Seguita dal nome della classe base
Gli oggetti della classe derivata sono, a tutti
gli effetti, estensioni della classe base
 Anche nella loro rappresentazione in memoria

/****************************************************************/
174Ereditarietà in Java
Veicolo.java
public class Veicolo {
private double velocità;
private double accelerazione;
public double getVelocità() {...}
public double getAccelerazione() {...}
}
public class Automobile
Automobile.java
extends Veicolo {
private boolean avviata;
public void avvia() {...}
}

/****************************************************************/
175Ereditarietà in Java
Automobile a=
new Automobile();
Memoria
velocità: 0.0
accelerazione: 0.0
a

/****************************************************************/
avviata: false
176Meccanismi
Costruzione di
oggetti di classi
derivate
Accesso alle
funzionalità della
superclasse
Ri-definizione di
metodi

/****************************************************************/
177Costruzione
Per realizzare un'istanza di una classe
derivata, occorre – innanzi tutto – costruire
l'oggetto base
 Di solito, provvede automaticamente il
compilatore, invocando – come prima operazione
di ogni costruttore della classe derivata – il
costruttore anonimo della superclasse
 Si può effettuare in modo esplicito, attraverso il
costrutto super(...)
 Eventuali ulteriori inizializzazioni possono essere
effettuate solo successivamente

/****************************************************************/
178Esempio
class Impiegato {
String nome;
double stipendio;
Impiegato(String n) {
nome = n;
stipendio= 1500; class Funzionario
extends Impiegato {
}
}
Funzionario(String n) {
super(n);
stipendio = 2000;
}
}

/****************************************************************/
179Accedere alla superclasse
L'oggetto derivato contiene tutti i
componenti (attributi e metodi) dell'oggetto
da cui deriva
 Ma i suoi metodi non possono operare
direttamente su quelli definiti privati
La restrizione può essere allentata:
 La super-classe può definire attributi e metodi
con visibilità “protected”
 Questi sono visibili alle sottoclassi

/****************************************************************/
180Ridefinire i metodi
Una sottoclasse può ridefinire metodi
presenti nella superclasse
A condizione che abbiano
 Lo stesso nome
 Gli stessi parametri (tipo, numero, ordine)
 Lo stesso tipo di ritorno
 (La stessa semantica!)
Per le istanze della sottoclasse, il nuovo
metodo nasconde l'originale

/****************************************************************/
181Ridefinire i metodi
class Base {
int m() {
return 0;
}
}
class Derivata
extends Base {
int m() {
return 1;
}
}
Base b= new Base();
System.out.println(b.m());
Derivata d= new Derivata();
System.out.println(d.m());

/****************************************************************/
182Ridefinire i metodi
A volte, una sottoclasse vuole “perfezionare”
un metodo ereditato, non sostituirlo in toto
 Per invocare l'implementazione presente nella
super-classe, si usa il costrutto
super. ( ... )
class Base {
int m() {
return 0;
}
}

/****************************************************************/
class Derivata
extends Base {
int m() {
return super.m()+ 1;
}
}
183Compatibilità formale
Un'istanza di una classe derivata è
formalmente compatibile con il tipo della
super-classe
 Base b = new Derivata( );
Il tipo della variabile “b” (Base) limita le
operazioni che possono essere eseguite
sull'oggetto contenuto
 Anche se questo ha una classe più specifica
(Derivata), in grado di offrire un maggior numero
di operazioni
 Altrimenti viene generato un errore di
compilazione

/****************************************************************/
184Compatibilità formale
C
print()
D
print()
reset()

/****************************************************************/
C v1= new C();
C v2= new D();
D v3= new D();
v1.print() 
v2.print() 
v2.reset() 
v3.reset() 
185Polimorfismo
class Base {
int m() {
return 0;
}
}
class Derivata
extends Base {
int m() {
return 1;
}
}
Base b= new Derivata();
System.out.println(b.m());

/****************************************************************/
186Polimorfismo
Java mantiene traccia della classe effettiva
di un dato oggetto
 Seleziona sempre il metodo più specifico...
 ...anche se la variabile che lo contiene
appartiene ad una classe più generica!
Una variabile generica può avere “molte
forme”
 Contenere oggetti di sottoclassi differenti
 In caso di ridefinizione, il metodo chiamato
dipende dal tipo effettivo dell'oggetto

/****************************************************************/
187Polimorfismo
Per sfruttare questa tecnica:
 Si definiscono, nella super-classe, metodi con
implementazione generica...
 ...sostituiti, nelle sottoclassi, da implementazioni
specifiche
 Si utilizzano variabili aventi come tipo quello della
super-classe
Meccanismo estremamente potente e
versatile, alla base di molti “pattern” di
programmazione

/****************************************************************/
188Esempio
Forma
area()
perimetro()
Cerchio Rettangolo
area()
perimetro() area()
perimetro()

/****************************************************************/
Forma f1 =
new Cerchio();
Forma f2 = new
Rettangolo();
double d1,d2;
d1=f1.area();
d2=f2.area();
189La classe java.lang.Object
In Java:
 Gerarchia di ereditarietà semplice
 Ogni classe ha una sola super-classe
Se non viene definita esplicitamente una
super-classe, il compilatore usa la classe
predefinita Object
 Object non ha super-classe!

/****************************************************************/
190Metodi di Object
 Object definisce un certo numero di metodi
pubblici
 Qualunque oggetto di qualsiasi classe li eredita
 La loro implementazione base è spesso minimale
 La tecnica del polimorfismo permette di ridefinirli
 public boolean equals(Object o)
 Restituisce “vero” se l'oggetto confrontato è identico (ha lo
stesso riferimento) a quello su cui viene invocato il metodo
 Per funzionare correttamente, ogni sottoclasse deve fornire
la propria implementazione polimorfica

/****************************************************************/
191Metodi di Object
 public String toString()
 Restituisce una rappresentazione stampabile dell'oggetto
 L'implementazione base fornita indica il nome della classe
seguita dal riferimento relativo all'oggetto
(java.lang.Object@10878cd)
 public int hashCode()
 Restituisce un valore intero legato al contenuto dell'oggetto
 Se i dati nell'oggetto cambiano, deve restituire un valore
differente
 Oggetti “uguali” devono restituire lo stesso valore, oggetti
diversi possono restituire valori diversi
 Utilizzato per realizzare tabelle hash

/****************************************************************/
192Controllare l'ereditarietà
 In alcuni casi, si vuole impedire esplicitamente
l'utilizzo della tecnica del polimorfismo
 Ad esempio, per motivi di sicurezza o per garantire il
mantenimento di una data proprietà del sistema
 Si utilizza la parola chiave “final”
 Un metodo “final” non può essere ridefinito da una
sottoclasse
 Una classe “final” non può avere sottoclassi
 Un attributo “final” non può essere modificato
 Non c'entra nulla con l'ereditarietà!

/****************************************************************/
193Controllare l'ereditarietà
In altri casi si vuole obbligare l'utilizzo del
polimorfismo
 Si introducono metodi privi di implementazione
 Facendoli precedere dalla parola chiave
“abstract”
Una classe che contiene metodi astratti
 Deve essere, a sua volta, dichiarata abstract
 Non può essere istanziata direttamente
 Occorre definire una sottoclasse che fornisca
l'implementazione dei metodi mancanti

/****************************************************************/
194Classi astratte
abstract class
Base {
abstract int m();
}
class Derivata
extends Base {
int m() {
return 1;
}
}
Base b= new Derivata();
System.out.println(b.m());

/****************************************************************/
195Interfacce
 Una classe astratta può contenere metodi non
astratti
 A beneficio delle proprie sottoclassi
 In alcuni casi, si vogliono definire metodi astratti
senza vincolare la gerarchia di ereditarietà delle
classi che li implementeranno
 Si utilizzano le interfacce:
 Insiemi di metodi astratti e costanti (attributi static final)
 Pubblici per definizione
 Una classe può implementare un'interfaccia
 Fornendo il codice relativo a tutti i metodi dichiarati
nell'interfaccia

/****************************************************************/
196Esempio
public interface Comparable {
public int compareTo(Object o);
}
public class Rettangolo extends Forma
implements Comparable {
public int compareTo(Object o) {
//codice relativo...
}
//altri attributi e metodi...
}

/****************************************************************/
197Interfacce e tipi
Analogamente alle classi, ogni interfaccia
definisce un tipo
 Un oggetto che implementa una data interfaccia
ha come tipo anche il tipo dell'interfaccia
 Un oggetto può implementare molte interfacce
 Di conseguenza può avere molti tipi
Si può verificare se un oggetto ha un dato
tipo con l'operatore “instanceof”
 if (myObject instanceof Comparable) ...

/****************************************************************/
198Interfacce vuote
Alcune interfacce non hanno metodi
 Servono solo come “marcatori” o indicatori di
tipo
 Indicano che gli oggetti delle classi che le
implementano godono di qualche proprietà

/****************************************************************/
199Interfacce vuote
public interface Clonable {
//indica che è lecito usare,
// sulle istanze di questa classe
// il metodo Object.clone()
}
public class Rettangolo extends Forma
implements Comparable , Clonable {
public int compareTo(Object o) {
//codice relativo...
}
//altri attributi e metodi...
}

/****************************************************************/
200Percorso
Eventi eccezionali
 Identificazione,
descrizione e
segnalazione
Eccezioni in Java
 I meccanismi offerti
 Le classi principali
Modellare le eccezioni

/****************************************************************/
201Affidabilità di un
programma
Un programma esegue una sequenza di
operazioni su un calcolatore
 Alcune direttamente, altre attraverso le
funzionalità offerte dal sistema operativo
Talvolta qualche operazione non può essere
effettuata
 Il programma deve accorgersene e reagire di
conseguenza

/****************************************************************/
202Le ragioni del fallimento
Mancanza di risorse
 Memoria esaurita, disco pieno, autorizzazioni
insufficienti, ...
Parametri errati
 Divisione per 0, riferimenti a risorse inesistenti
(file, URL), ...
Sequenza illecita di operazioni
 Utilizzo di riferimenti nulli, scrittura su file
chiuso, ...

/****************************************************************/
203Le ragioni del fallimento
Alcune dipendono dal programmatore
 Altre, dal contesto di esecuzione
In ogni caso, quando si rileva un'anomalia
 Non è possibile concludere l'operazione in corso
 Il programma, nel suo complesso, viene a
trovarsi in uno stato incoerente
Per garantire l'affidabilità del sistema,
occorre mettere in atto una strategia di
rilevazione e gestione delle eccezioni

/****************************************************************/
204Strategie
Tutte le operazioni che possono fallire,
devono indicare:
 Se sono terminate con successo o meno
 L'eventuale anomalia riscontrata
Alcuni linguaggi si basano su valori di ritorno
 Occorre verificarli
 Il diagramma di flusso si complica notevolmente
 Se si omette un test, si compromette la capacità
di valutare l'integrità del sistema

/****************************************************************/
205Esempio
Semplice
procedura:
 Tre operazioni
in successione
 Ciascuna può fallire
Apri il file
Scrivi
Chiudi il file

/****************************************************************/
206Esempio
Scrivi
Apri il file
no
OK?
si

/****************************************************************/
no
OK?
Chiudi il file
si
no
OK?
si
207Complessità
Rapidamente, il codice
associato ad una
procedura semplice
diventa ingestibile
 La reazione comune
consiste nell'omettere i
test
Cosa fare quando si
rileva un
malfunzionamento?

/****************************************************************/
208Contesto
Spesso, ci si accorge dei fallimenti all'interno
di procedure generiche
 Non si sa quali contromisure prendere
Occorrerebbe segnalare il
malfunzionamento al chiamante
 Fornendo la descrizione più accurata possibile di
quanto successo
 Il chiamante può gestire l'eccezione o
rimandarne la gestione al proprio chiamante,
ricorsivamente...

/****************************************************************/
209La risposta di Java
Un'insieme di classi per modellare
l'anomalia riscontrata
 Fa capo alla classe Throwable
Meccanismi per
 Segnalare
 Gestire
 Propagare
un'anomalia, attraverso la catena di
invocazione dei metodi

/****************************************************************/
210Sintassi
 Un metodo che può fallire deve segnalarlo nella
propria dichiarazione
 Attraverso la parola chiave “throws”
 Seguita dal tipo (o dai tipi) di eccezione che si può
verificare durante l'esecuzione
 Chi invoca tale metodo deve:
 Cercare di gestire la possibile anomalia attraverso il
costrutto “try” / “catch”
 Oppure, segnalare che a propria volta può generare la
stessa anomalia: l'eccezione si propaga al chiamante del
chiamante

/****************************************************************/
211Esempio
Segnala che
double div(int num, int den) puo' fallire
Verifica la
coerenza
throws Exception
{
Interrompe
if (den==0)
Descrive
l'esecuzione
l'anomalia
del
metodo
throw
new Exception(“div 0”);
return num/den;
}

/****************************************************************/
212Try/Catch
Costrutto utilizzato per il controllo delle
eccezioni
 Isola le parti di codice che possono provocare
anomalie
try{
... // codice da controllare
} catch(...Exception e){
... // gestione anomalia
}

/****************************************************************/
213Try/Catch
È possibile reagire in modo differente a tipi
diversi di eccezioni mettendo più clausole
“catch” in sequenza
 Avendo cura di indicare dapprima le anomalie più
specifiche
try{
...
} catch(ExceptionA e1){ ...
} catch(ExceptionB e2){ ...
}

/****************************************************************/
214La clausola “finally”
 finally indica le istruzioni che devono essere
eseguite comunque
 Tanto nel caso in cui il codice controllato sia stato eseguito
correttamente
 Quanto nel caso in cui si sia verificata un'eccezione
try{
... // codice da controllare
} catch(Exception e){
... // gestione dell'anomalia
} finally {
... // istruzioni da eseguire
// in ogni caso
}

/****************************************************************/
2151)
try{
...
...
} catch(ExcA e1){
...
} catch(ExcB e2){
...
} finally {
...
}

/****************************************************************/
Qualunque
anomalia in
questo blocco
determina
l'interruzione
dell'esecuzione
2162)
try{
...
...
} catch(ExcA e1){
...
} catch(ExcB e2){
...
} finally {
...
}

/****************************************************************/
Si confronta
il tipo segnalato
con quelli indicati
nelle clausole
“catch”:
si seleziona
la prima
corrispondenza
trovata
2173)
try{
...
...
} catch(ExcA e1){
...
} catch(ExcB e2){
...
} finally {
...
}

/****************************************************************/
Si esegue
il blocco
di codice
corrispondente:
la segnalazione
dell'anomalia
viene rimossa
2184)
try{
...
...
} catch(ExcA e1){
...
} catch(ExcB e2){
...
} finally {
...
}

/****************************************************************/
Comunque
siano andate
le cose, viene
eseguito il blocco
“finally”,
se presente
219Problemi
Il codice del blocco catch selezionato
dovrebbe ripristinare la coerenza nel
sistema
 Non è detto sia possibile!
È possibile che si verifichi un'eccezione
durante l'esecuzione del blocco catch
 Può dare origine ad una struttura di
programmazione alquanto complessa
 Può essere indice di cattiva progettazione

/****************************************************************/
220Gestire le eccezioni
Stampare un messaggio di errore
 Non risolve nulla, ma aiuta il debugging
try{
...
} catch(Exception e1){
e1.printStackTrace();
}

/****************************************************************/
221Gestire le eccezioni
Generare una nuova eccezione
 Permette di aggiungere informazioni sul contesto
in cui si è verificata l'anomalia originale
try{
...
} catch(Exception e1){
throw new MyExc(e1,new Date());
}

/****************************************************************/
222Gestire le eccezioni
Rilanciare la stessa eccezione
 Avendo compiuto qualche azione a margine
try{
...
} catch(Exception e1){
Logger.log(e1.getMessage());
throw e1;
}

/****************************************************************/
223Gestire le eccezioni
Correggere l'anomalia...
 ...e riprovare l'azione
 Facendo attenzione ai cicli infiniti
boolean done = false;
do {
try{ ... ; done = true; }
catch(Exception e1){
//correggi l'anomalia ...
}
while (! done);

/****************************************************************/
224Gestire le eccezioni
Ripristinare uno stato precedente...
 ...disfacendo eventuali azioni non terminate
(rollback)
ContoCorrente a,b; //...
int stato =0;
double somma;
try {
a.preleva(somma);
stato = 1;
b.deposita(somma);
stato = 2;
}
catch(Exception e1){
if (stato == 1)
a.deposita(somma);
}

/****************************************************************/
225Gestire le eccezioni
Interrompere l'esecuzione
 Disastro irreparabile!
try{
...
} catch(Exception e1){
System.exit(0);
}

/****************************************************************/
226Gestire le eccezioni
Non fare nulla
 La peggior scelta possibile!
 Da non fare mai
try{
...
} catch(Exception e1){
//nessuna azione!
}

/****************************************************************/
227Modellare le eccezioni
Java prevede che un'anomalia sia descritta
da un oggetto di tipo Throwable
 Classe radice della gerarchia delle eccezioni
 Offre vari metodi per la gestione dell'anomalia
 Le sue sottoclassi modellano diversi tipi di
malfunzionamenti

/****************************************************************/
228La classe Throwable
String getMessage()
 Restituisce la stringa che descrive l'anomalia
 Inizializzata nel costruttore a partire da un
parametro
void printStackTrace()
 Stampa la posizione in cui si è verificata
l'eccezione e la sequenza dei metodi chiamanti
ad essa relativi
 Riporta anche, se disponibili, i riferimenti alle
righe, nei file sorgente, in cui si sono verificate le
successive invocazioni

/****************************************************************/
229Tipologie di anomalie
 Errori della macchina virtuale
 Fanno capo alla classe Error
 Non possono essere recuperati
 Memoria esaurita, stack overflow, ...
 Errori di programma
 Fanno capo alla classe Exception
 Per lo più, devono essere gestiti in modo esplicito,
dichiarandone l'eventualità nei metodi che li possono
generare e utilizzando costrutti di tipo “try”
 Alcuni possono capitare pressoché sempre
(RuntimeException): non occorre dichiarare
esplicitamente la possibilità che si verifichino

/****************************************************************/
230Gerarchia delle eccezioni
unrecoverable
problems
Throwable
Error
Stack
Overflow
‘checked'
exceptions
Exception
RuntimeException
IOException

/****************************************************************/
‘unchecked'
exceptions
NullPointer
Exception
231Definire nuove eccezioni
È possibile creare classi di eccezioni
personalizzate
 Spesso non contengono nessun metodo né
attributo
 Di solito, hanno un costruttore anonimo, che
associa all'oggetto una descrizione generica ed
un costruttore che accetta una stringa, che
permette di dettagliare l'anomalia verificatasi

/****************************************************************/
232Esempio
public class MyException
extends Exception {
public MyException() {
super(“MyException”);
}
public MyException(String s){
super(“MyException: ”+s);
}
}
...
throw new MyException(“message”);
...

/****************************************************************/
233

Flussi di dati
Lettura e scrittura
Interagire con
il file system
File ad accesso
casuale

/****************************************************************/
234Flussi di dati
 Sequenze continue e monodirezionali di
informazioni che transitano da un'entità ad
un'altra
 Attraverso un flusso possono scorrere dati
di qualsiasi tipo:
 Omogenei / eterogenei
 Semplici / composti
 Un programma costituisce la sorgente o la
destinazione di un flusso
 L'altra estremità può essere un altro
programma, il disco, lo schermo o la tastiera,
... ad Oggetti
Programmazione
235Classi Java per I/O
 Modellano l'interazione di un programma
con flussi dati
 Ingresso o uscita
 Binari o testuali
 Organizzate in una struttura di ereditarietà
 Le sottoclassi estendono e specializzano le
funzionalità base
 Fanno capo al package java.io

/****************************************************************/
236Struttura generale
InputStream
OutputStream
Binario
Reader
Ingresso Testuale

/****************************************************************/
Writer
Uscita
237InputStream
Modella le operazioni di lettura da un flusso
binario
 Opera su sequenze di byte
 Classe astratta
Offre metodi per leggere i singoli byte
 Tutti i metodi possono lanciare IOException

/****************************************************************/
238Metodi principali
int read()
 Attende il prossimo byte, dopodiché ne
restituisce il valore (0-255)
 Ritorna -1 se il flusso è terminato
int available()
 Ritorna il numero di byte leggibili senza attesa

/****************************************************************/
239Metodi principali
 long skip(long n)
 Scarta i prossimi “n” byte dal flusso, se
esistono
 Ritorna il numero di caratteri scartati
 void close()
 Chiude il flusso e rilascia le risorse di sistema
associate
 Occorre ricordarsi di chiamarlo!

/****************************************************************/
240Sorgenti
 InputStream offre funzionalità minimali:
 Non indica da dove provengano i dati letti
 Sottoclassi “sorgente”
 Modellano la lettura di byte da supporti specifici
 File, array di byte, StringBuffer, ...

/****************************************************************/
241FileInputStream
Permette di leggere il contenuto di un file
 Parametro del costruttore
 Deve esistere ed essere leggibile
Lettura sequenziale
 Dall'inizio alla fine

/****************************************************************/
242Esempio
FileInputStream fis;
String filename= “prova.dat”;
try {
fis= new FileInputStream(filename);
int i;
while ( (i=fis.read()) != -1) {
byte b= (byte) i;
//Opera sul dato...
}
} finally { fis.close(); }

/****************************************************************/
243Filtri
 InputStream offre funzionalità minimali:
 Permette solo di leggere byte
 Classi “filtro”
 Arricchiscono le funzionalità o le prestazioni,
interponendosi ad altre sorgenti o filtri

/****************************************************************/
244Classi filtro
 Richiedono un InputStream da cui prelevare
i dati
 Deve essere passato nel costruttore
 Trasformano i dati letti da tale flusso
 Conversione di formato, memoria tampone,
reinserimento, ...

/****************************************************************/
245Classi filtro
BufferedInputStream bis;
bis=new BufferedInputStream(
new FileInputStream(“file.dat”)
);
byte b=bis.read(); b=bis.read();
File
InputStream
read()
...

/****************************************************************/
File
246Classi filtro
BufferedInputStream bis;
bis=new BufferedInputStream(
new FileInputStream(“file.dat”)
);
byte b=bis.read(); b=bis.read();
Buffered
InputStream
read()
...
is
buf
count

/****************************************************************/
File
InputStream
read()
...
File
byte[]
247Classi filtro
BufferedInputStream bis;
bis=new BufferedInputStream(
new FileInputStream(“file.txt”)
);
byte b=bis.read(); b=bis.read();
Buffered
InputStream
read()
...
is
buf
count

/****************************************************************/
File
InputStream
read()
...
File
byte[]
248Classi filtro
BufferedInputStream bis;
bis=new BufferedInputStream(
new FileInputStream(“file.txt”)
);
byte b=bis.read(); b=bis.read();
Buffered
InputStream
read()
...
is
buf
count

/****************************************************************/
File
InputStream
read()
...
File
byte[]
249Composizione
Il meccanismo dei filtri è molto flessibile
 Più filtri possono essere concatenati (in che
ordine?)
 Si possono costruire oggetti con tutte e sole le
funzionalità richieste

/****************************************************************/
250Gerarchia di ereditarietà
Input
Stream
File
InputStream
ByteArray
Sequence
InputStream
InputStream Filter InputStream StringBuffer
Buffered Data Pushback
InputStream

/****************************************************************/
InputStream
InputStream
InputStream
251OutputStream
Modella le operazioni di scrittura su un
flusso binario
 Classe astratta
Offre metodi per scrivere i singoli byte
 Tutti i metodi possono lanciare IOException

/****************************************************************/
252Metodi principali
void write(int b)
 Scrive il valore b (troncato ad 8 bit) sul flusso
void flush()
 Forza l'invio effettivo di byte temporaneamente
accodati all'interno dell'oggetto
void close()
 Chiude il flusso e rilascia le risorse di sistema
associate
 Una volta chiuso, il flusso non può essere
riaperto né può ricevere ulteriori dati
 Occorre ricordarsi di chiamarlo

/****************************************************************/
253Destinazioni
 Anche OutputStream offre funzionalità
minimali:
 Non indica dove scrivere i dati letti
 Sottoclassi “destinazione”
 Modellano la scrittura di byte su supporti
specifici
 File, array di byte, ...

/****************************************************************/
254FileOutputStream
 Permette di scrivere un file
 Parametro del costruttore
 Può non esistere
 Occorre poterlo creare / modificare (diritto di
scrittura)
 Scrittura sequenziale
 Dall'inizio alla fine
 Il contenuto precedente viene cancellato

/****************************************************************/
255Esempio
FileOutputStream fos;
String filename= “prova.dat”;
try {
fos= new FileOutputStream(filename);
//Esempio di scrittura...
for (int i=0; i<=255; i++)
fos.write( (byte) i);
} finally { fos.close(); }

/****************************************************************/
256Filtri
 Insieme di classi che estendono le capacità
di OutputStream
 Inserimento di un buffer
 Scrittura di dati elmentari ed oggetti
 Scrittura di sequenze di caratteri ASCII

/****************************************************************/
257Gerarchia di ereditarietà
Output
Stream
File
OutputStream
ByteArray
Object
OutputStream
Filter
Piped
OutputStream OutputStream OutputStream
Buffered Data Print
OutputStream

/****************************************************************/
OutputStream
Stream
258Reader & Writer
 Classi duali di InputStream e OutputStream
 Modellano operazioni su flussi di caratteri
UNICODE
 Classi astratte
 Rispetto ai flussi binari, cambiano i tipi dei
parametri

/****************************************************************/
259Gerarchia di ereditarietà
Reader
Buffered
Filter
Reader
CharArray
Reader
Reader
InputStream
Reader
String
Reader
File
Reader

/****************************************************************/
260Gerarchia di ereditarietà
Writer
Buffered
Print
Writer
CharArray
Writer
Writer
OutputStream
Writer
String
Writer
File
Writer

/****************************************************************/
261Codifica dei caratteri
 Un carattere UNICODE è rappresentato su
16 bit
 Esistono vari modi per trasformarlo in una
sequenza di byte
 InputStreamReader e OutputStreamWriter
hanno, all'interno, il codice necessario alla
conversione in byte
 Nel costruttore si può indicare la codifica da
adottare

/****************************************************************/
262Leggere da console
BufferedReader br;
try {
br= new BufferedReader(
new InputStreamReader(System.in)
);
String s=br.readLine();
...
} finally { br.close(); }

/****************************************************************/
263La classe File
Modella il nome di file e cartelle in modo
indipendente dal sistema operativo:
 Il file corrispondente può non esistere
 Permette di creare, cancellare, rinominare, ... file e
cartelle

/****************************************************************/
264Creazione e
cancellazione
boolean createNewFile();
boolean mkdir();
boolean renameTo(File dest);
boolean delete();
void deleteOnExit();

/****************************************************************/
265Proprietà di un file







boolean canRead();
boolean canWrite();
boolean isDirectory();
boolean isFile();
File getParentFile();
long length();
String[] list();

/****************************************************************/
266Ulteriori funzionalità
 static File[] listRoots();
 Elenca le possibili radici del filesystem corrente
(“a:”, “c:”, ...)
 static String separator;
 Indica il carattere che separa il nome di cartelle
e file (‘\' o ‘/')

/****************************************************************/
267Esempio
File dir= new File(“c:\”, “temp”);
boolean b;
if (!dir.exists())
b=dir.mkdir();
else
b=dir.isDirectory();
if (b) {
String[] nomi= dir.list();
//...
}

/****************************************************************/
268File ad accesso casuale
 In alcune situazioni occorre operare su un file,
procedendo in modo non sequenziale
 Lettura e scrittura possono avvenire in qualsiasi posizione
del file
 indipendentemente dall'operazione precedente
 La classe RandomAccessFile modella il file come
fosse un array di byte
 Memorizzato su disco, invece che in memoria
 Mantiene un puntatore di posizione interno che tiene
traccia del prossimo byte a cui accedere
o Modificabile dal programmatore
 È possibile operare sia in lettura che in scrittura
o Si specifica in fase di costruzione

/****************************************************************/
269File ad accesso casuale
DataInput
DataOutput
RandomAccessFile
read( )
write( )
seek( pos )
...
File
pos
File
Posizione in cui avverrà
la prossima operazione

/****************************************************************/
270Operare in lettura
 void seek(long pos)
 Posiziona il puntatore interno a pos byte dall'inizio del file
 long getFilePointer( )
 Restituisce la posizione corrente del puntatore interno
rispetto all'inizio del file
 String readLine( )
 Legge una sequenza di caratteri ASCII terminata da
newline e la converte in formato Unicode
 String readUTF( )
 Legge una sequenza di caratteri Unicode codificati nel
formato UTF-8 (che contiene la lunghezza della stringa)
 Altri metodi dell'interfaccia DataInput
 Permettono di leggere tipi elementari (numeri interi, numeri
in virgola mobile, caratteri e booleani)

/****************************************************************/
271Operare in scrittura
 void writeBytes(String s)
 Scrive la sequenza di byte meno significativi corrispondenti
ai caratteri contenuti in “s”
 void writeChars(String s)
 Scrive la sequenza di caratteri (due byte ciascuno)
contenuti in “s”
 void writeUTF(String s)
 Scrive la rappresentazione della stringa “s” nel formato
UTF-8
 Altri metodi dell'interfaccia DataOutput
 Permettono la scrittura di dati elementari

/****************************************************************/
272