Schede



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

# Il 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

# Codice 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

# Un 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”);
}
}

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

# I passi concettuali (2)
Esecuzione
1001
0110
110..
.class
ByteCode

# Gli strumenti di Java
## La macchina virtuale
## Il compilatore
## Gli ambienti di sviluppo
## La documentazione
## Il debugger

# Macchina virtuale (1)
Applicazione
tradizionale
Applicazione
Java
Macchina
Virtuale
Sistema Operativo
Hardware

# Macchina 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

# Il 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= ... ;<JAVA_HOME>/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
* <Tipo> <Nome> ‘;'
* <Tipo> <Nome> ‘=' <ValoreIniziale> ‘;'
## 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
<tipoRitornato> 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, <vuoto>)

#
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.<nomeMetodo> ( ... )
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
Le classi in Java


concetti che sono alla base di un programma Java:
classe
Nel mondo reale, una classe indicherebbe un concetto, un'idea, un modello.
oggetto
Un oggetto è un'istanza (cioè una creazione fisica) di una classe.

Una classe può contenere (dichiarare) un numero variabile di
attributi
metodi
costruttori
package
altri oggetti

Una classe è il modello astratto da cui creare oggetti.
Una classe si limita a definire la struttura che avranno gli oggetti creati
a partire da essa stessa.
Una classe è la rappresentazione generale di una certa
tipologia di oggetti ed è usata, al momento dell'esecuzione del programma, per
realizzare istanze della classe stessa: gli oggetti.

DICHIARAZIONE CLASSE In Java una classe viene dichiarata in questo modo.

public class NomeClasse { // dichiarazione variabili // dichiarazione metodi }


Il corpo della classe (tra parentesi graffe) contiene tutto il codice che
determina il ciclo di vita degli oggetti creati dalla classe stessa:

costruttori,
dichiarazioni delle variabili
dichiarazioni dei metodi.

In un approccio object oriented, una classe dovrebbe limitarsi a definire
la struttura comune di un insieme di oggetti e non dovrebbe mai possedere
né variabili né metodi.

DICHIARAZIONE E CREAZIONE OGGETTO
La creazione di un oggetto può avvenire in modi diversi.

Si può dichiarare e istanziare un oggetto in diverse righe di codice

NomeClasse NomeOggetto;
NomeOggetto = new NomeClasse();

Oppure accorpando dichiarazione e creazione nella stessa riga di codice.

NomeClasse NomeOggetto = new NomeClasse();

Solo dopo l'istanziazione (la creazione) dell'oggetto è possibile utilizzarlo.
I membri della classe Object.
--------------------------------------
Costruttori pubblici:
Object()
--------------------------------------
Metodi protetti:
Object clone()
void finalize()
--------------------------------------
Metodi pubblici:
boolean equals(Object obj)
final Class getClass()
int hashCode()
final void notify()
final void notifyAll()
String toString()
final void wait()
final void wait(int millis)
final void wait(int millis, int nanos)
I membri della classe System.
----------------------------------------------------------------------------
Costanti pubbliche statiche:
java.io.PrintStream err
java.io.InputStream in
java.io.PrintStream out
----------------------------------------------------------------------------
Metodi pubblici statici:
void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
long currentTimeMillis()
void exit(int status)
void gc()
java.util.Properties getProperties()
String getProperty(String key)
String getProperty(String key, String default) SecurityManager
getSecurityManager()
void runFinalization()
void setErr(java.io.PrintStream err)
void setIn(java.io.InputStream in)
void setOut(java.io.PrintStream out)
void setProperties(java.util.Properties properties) String
setProperty(String key, String value)
void setSecurityManager(SecurityManager s)
I membri della classe Math.
--------------------------------------
Costanti pubbliche statiche:
double E
double PI
--------------------------------------
Metodi pubblici statici:
double abs(double a)
float abs(float a)
int abs(int a)
long abs(long a)
double acos(double a)
double asin(double a)
double atan(double a)
double atan2(double y, double x)
double ceil(double a)
double cos(double a)
double exp(double a)
double floor(double a)
double log(double a)
double max(double a, double b)
float max(float a, float b)
int max(int a, int b)
long max(long a, long b)
double min(double a, double b)
float min(float a, float b)
int min(int a, int b)
long min(long a, long b)
double pow(double a, double b)
double random()
double rint(double a)
long round(double a)
int round(float a)
double sin(double a)
double sqrt(double a)
double tan(double a)
double toDegrees(double angrad)
double toRadians(double angdeg)
I membri della classe Random.
--------------------------------------------------------------
Costruttori pubblici:
Random() Costruisce un nuovo generatore
di numeri pseudo-casuali,
usando la data e l'ora
correnti come seme.
Random(int seed) Costruisce un nuovo generatore
di numeri pseudo-casuali,
usando il seme specificato.
--------------------------------------------------------------
Metodi pubblici:
boolean nextBoolean() Restituisce il boolean
successivo nella sequenza
pseudo-casuale.
void nextBytes(bytes[] b) Registra sull'argomento
fornito una sequenza di
b.length numeri
pseudo-casuali, in formato
byte.
double nextDouble() Restituisce il double
successivo nella sequenza
pseudo-casuale, compreso tra 0
(incluso) ed 1 (escluso).
float nextFloat() Restituisce il float
successivo nella sequenza
pseudo-casuale, compreso tra 0
(incluso) ed 1 (escluso).
double nextGaussian() Restituisce il double
gaussiano successivo nella
sequenza pseudo-casuale,
compreso tra 0 (incluso) ed 1
(escluso).
int nextInt() Restituisce l'int successivo
nella sequenza pseudo-casuale.
int nextInt(int n) Restituisce l'int successivo
nella sequenza pseudo-casuale,
compreso tra 0 (incluso) ed n
(escluso).
long nextLong() Restituisce il long successivo
nella sequenza pseudo-casuale.
void setSeed(long seed) Reimposta il seme della
sequenza.
I membri della classe ArrayList.
--------------------------------------------------------------
Costruttori pubblici:
ArrayList() Costruisce una lista di tipo
ArrayList inizialmente vuota.
--------------------------------------------------------------
Metodi pubblici:
void add(int i, Object o) Aggiunge l'oggetto o alla
lista, disponendolo alla
posizione i. Se la posizione
è già occupata, l'elemento
corrispondente e tutti i suoi
successivi verranno avanzati
di un posto.
boolean add(Object o) Aggiunge l'oggetto o in coda
alla lista.
void clear() Ripulisce la lista, eliminando
tutti i suoi elementi.
Object clone() Clona l'oggetto. ArrayList
implementa l'interfaccia
cloneable.
boolean contains(Object o) Restituisce true se la lista
contiene l'oggetto o.
boolean equals(Object o) Restituisce true se o è una
lista dal contenuto identico
all'oggetto di invocazione.
Object get(int i) Restituisce l'elemento alla
posizione i.
int indexOf(Object o) Restituisce l'indice
dell'elemento o, o -1 se
l'elemento non compare nella
lista.
boolean isEmpty() Restituisce true se la lista
è vuota.
Object remove(int i) Individua l'elemento alla
posizione i, lo rimuove dalla
lista e lo restituisce al
codice chiamante. Tutti gli
elementi successivi saranno
arretrati di una posizione.
Object set(int i, Object o) Sostituisce con o l'elemento
alla posizione i. Restituisce
l'elemento rimpiazzato.
int size() Restituisce il numero di
elementi nella lista.
Object[] toArray() Converte la lista in un
array.
I membri resi disponibili dalla classe Date.
--------------------------------------------------------------
Costruttori pubblici:
Date() Costruisce un oggetto Date che incapsula la data
e l'ora correnti.
Date(long t) Costruisce un oggetto Date che
incapsula la data e l'ora
espressi dall'argomento t.
L'argomento è un long che
riporta i millisecondi
trascorsi dal 1 Gennaio 1970
sino alla data rappresentata.
--------------------------------------------------------------
Metodi pubblici:
boolean after(Date d) Restituisce true se la data di
invocazione è successiva alla
data d.
boolean before(Date d) Restituisce true se la data di
invocazione è precedente alla
data d.
Object clone() Clona l'oggetto. Date
implementa l'interfaccia
Cloneable.
int compareTo(Date d) Compara la data di invocazione
con d. Restituisce 0 se le due
date sono uguali, un valore
negativo se la data di
invocazione precede la data d
o un valore positivo se la
data di invocazione è
successiva alla data d.
int compareTo(Object) Se l'argomento fornito è una
istanza di Date, agisce come
compareTo(Date d). In caso
contrario, propaga una
ClassCastException.
boolean equals(Object o) Restituisce true se
l'argomento è una data
equivalente a quella di
invocazione.
long getTime() Restituisce la data
dell'oggetto sotto forma di
valore long, che esprime i
millisecondi trascorsi dal 1
Gennaio 1970 sino alla data
rappresentata.
int hashCode() Calcola un codice hash per
l'oggetto.
void setTime(long t) Imposta la data rappresentata
con un argomento di tipo long,
che esprime i millisecondi
trascorsi dal 1 Gennaio 1970
sino alla data rappresentata.
String toString() Fornisce una rappresentazione
in stringa della data.
I membri pi� importanti classe GregorianCalendar.
--------------------------------------------------------------
Costruttori pubblici:
GregorianCalendar Costruisce un
GregorianCalendar che
rappresenta la data e l'ora
correnti.
GregorianCalendar(int Costruisce un
year, int month, int date) GregorianCalendar che
rappresenta la data espressa
mediante gli argomenti
forniti.
GregorianCalendar(int Costruisce un
year, int month, int date, GregorianCalendar che
int hour, int minute) rappresenta la data e l'ora
espressa mediante gli
argomenti forniti.
--------------------------------------------------------------
Metodi pubblici:
boolean after(Object o) Restutuisce true se la data
rappresentata è successiva
alla data espressa
dall'oggetto o, che deve
essere istanza di Calendar.
boolean before(Object o) Restutuisce true se la data
rappresentata è precedente
alla data espressa
dall'oggetto o, che deve
essere istanza di Calendar.
Object clone() Clona l'oggetto.
GregorianCalendar implementa
l'interfaccia Cloneable.
booleans equals(Object o) Restituisce true se
l'argomento rappresenta una
data equivalente a quella
rappresentata dall'oggetto
di invocazione.
int get(int field) Recupera il valore di uno
dei campi della data
rappresentata. L'argomento
specifica il campo di
interesse.
Date getTime() Restituisce un oggetto Date
che rappresenta la data
incapsulata dall'oggetto di
invocazione.
long getTimeInMillis() Restituisce la data
rappresentata dall'oggetto
sotto forma di valore long,
che esprime i millisecondi
trascorsi dal 1 Gennaio
1970 sino alla data
rappresentata.
int hashCode() Calcola un codice hash per
l'oggetto.
void set(int field, int value) Imposta su value il valore
del campo rappresentato
dall'intero field.
void setTime(Date d) Imposta la data rappresentata
prelevando il suo valore
all'argomento d.
void SetTimeInMillis(long l) Imposta la data rappresentata
mediante un argomento di tipo
long, che esprime i
millisecondi trascorsi dal 1
Gennaio 1970 sino alla data
rappresentata.
String toString() Fornisce una rappresentazione
in stringa della data.
rappresentata.
--------------------------------------------------------------
Costanti statiche:
AM_PM Il campo che informa se l'ora
espressa è prima o dopo
mezzogiorno.
DAY_OF_MONTH Il campo che riporta il giorno
del mese.
DAY_OF_WEEK Il campo che riporta il giorno
della settimana.
DAY_OF_YEAR Il campo che riporta il giorno
dell'anno.
HOUR Il campo che riporta l'ora del
mattino o del pomeriggio, a
seconda del contenuto del
campo AM_PM:
HOUR_OF_DAY Il campo che riporta l'ora del
giorno, in un intervallo tra
0 e 23.
MILLISECOND Il campo che riporta i
millisecondi.
MINUTE Il campo che riporta i minuti.
MONTH Il campo che riporta il mese.
SECOND Il campo che riporta i
secondi.
WEEK_OF_MONTH Il campo che riporta la
settimana del mese.
WEEK_OF_YEAR Il campo che riporta la
settimana dell'anno.
YEAR Il campo che riporta l'anno.
I membri di InputStream.
--------------------------------------------------------------
Metodi pubblici:
int available() Restituisce il numero di byte
che ancora devono essere
letti.
void close() Chiude lo stream.
void mark(int readlimit) Memorizza l'attuale posizione
dello stream, in modo che poi
sia possibile tornarci
chiamando reset(). Dopo
readlimit byte letti,
comunque, la posizione viene
dimenticata.
boolean markSupported() Restituisce true se lo stream
corrente supporta la
funzionalità offerta da
mark() e reset().
int read() Legge un byte dallo stream, e
lo restituisce come valore
int. Restituisce -1 se lo
stream ha raggiunto il
termine.
int read(byte[] b) Come read(b, 0, b.length).
int read(byte[] b, int off, Legge len byte dallo stream,
int len) salvandoli nell'array b, a
partire dalla posizione off.
Restituisce il numero di byte
effettivamente letti, o -1 se
la fine dello stream è stata
raggiunta.
void reset() Torna al punto raggiunto
nello stream l'ultima volta
che è stato chiamato mark().
long skip(long n) Avanza di n byte nello
stream, senza leggerli.
Restituisce il numero dei
byte effettivamente saltati.
I membri di OutputStream.
--------------------------------------------------------------
Metodi pubblici:
void close() Chiude lo stream.
void flush() Scrive il buffer nello stream.
void write(int b) Scrive un byte nel buffer o
nello stream.
void write(byte[] b) Scrive tutti i byte di b nel
buffer o nello stream.
void write(byte[] b, int off, Scrive len byte nel buffer o
int len) nello stream, prelevandoli
dall'array b a partire dalla
posizione off.
 In Java esistono diversi modi per leggere da standard input.

Il più generico (e più complesso) BufferedReader:

package letturatastiera;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class LetturaDaTastiera {

public static void main(String[] args) throws IOException {

InputStreamReader is = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(is);

System.out.println("Inserire una stringa:");
String letta = br.readLine();

System.out.println("Stringa letta: " +letta);
}
}

Con questo codice possiamo gestire qualunque tipo di input,
non solo quello da tastiera ( File, stream di dati dalla rete, ecc, ecc...).


Metodologie più compatte e rapide per un linguaggio come Java.

-------------
Scanner:
-------------

package letturatastiera;

import java.util.Scanner;

public class LetturaScanner {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

System.out.println("Inserisci una stringa:");
String letta = sc.next();

System.out.println("Ho letto: " + letta);
}
}


Da notare che per leggere un altro tipo di dato, ad esempio un intero,
avremmo dovuto scrivere:

String letta = sc.nextInt();


--------------------
JOptionPane:
--------------------

package letturatastiera;

import javax.swing.JOptionPane;

public class LetturaJOptionPane {

public static void main(String[] args) {

String letta =
JOptionPane.showInputDialog("Inserisci una stringa:");
System.out.println("Ho letto: " + letta);
}
}

In questo caso avremmo potuto mostrare la stringa letta in un JOptionPane,
invece che sullo standard output, semplicemente con:

JOptionPane.showMessageDialog(null, letta);



In tutti e tre i casi possiamo convertire la stringa letta in un intero
(o altri formati), utilizzando le classi di parsing di Java:

int numeroLetto = Integer.parseInt(letta);



La classe principale per trattare date ed ore in Java è 
java.util.GregorianCalendar che estende la classe astratta java.util.Calendar
e sostituisce la ormai deprecata classe java.util.Date.

Per creare un oggetto di classe GregorianCalendar che contenga
la data e l'ora corrente, basta richiamare il costruttore senza parametri.

GregorianCalendar dataAttuale=new GregorianCalendar();

Per ottenere informazioni sull'ANNO, MESE, GIORNO e ORA si utilizza
il metodo get() passandogli come paramentro
le costanti statiche definite nella classe (YEAR, MONTH, DAY, ...)


int anno = dataAttuale.get(GregorianCalendar.YEAR);

int mese = dataAttuale.get(GregorianCalendar.MONTH) + 1; //i mesi partono da 0

int giorno = dataAttuale.get(GregorianCalendar.DATE);

int ore = dataAttuale.get(GregorianCalendar.HOUR);

int minuti = dataAttuale.get(GregorianCalendar.MINUTE);

int secondi = dataAttuale.get(GregorianCalendar.SECOND);

La classe GregorianCalendar implementa dei metodi per effettuare confronti
ed operazioni con le date.

---------------------
Confronto di due date
---------------------

GregorianCalendar data1 = new GregorianCalendar(2008, 11, 18);
GregorianCalendar data2 = new GregorianCalendar(2007, 11, 10);
if ( data1.before(data2) ) {
System.out.println("data 1 precede data 2");
} else if ( data1.after(data2) ) {
System.out.println("dati 2 precede data 1");
} else {
System.out.println("Le date sono uguali");
}

--------------------------
Somma sottrazione di Date
--------------------------

GregorianCalendar data = new GregorianCalendar(2008, 11, 18);
data.add(GregorianCalendar.DATE, +33); // Aggiungo 33 giorni
data.add(GregorianCalendar.YEAR, -1); // Tolgo 1 anno
//Come Add, ma non modifica altri campi come DAY e YEAR
data.roll(GregorianCalendar.MONTH, +1);

---------------------------------
Differenza in giorni tra due date
---------------------------------

GregorianCalendar data1 = new GregorianCalendar(2008, 11, 18);
GregorianCalendar data2 = new GregorianCalendar(2007, 11, 10);
long milliseconds1 = data1.getTimeInMillis();
long milliseconds2 = data1.getTimeInMillis();
long diff = milliseconds2 - milliseconds1;
long diffSeconds = diff / 1000; //differenza in secondi
long diffMinutes = diff / (60 * 1000); //differenza in minuti
long diffHours = diff / (60 * 60 * 1000); //differenza in ore
long diffDays = diff / (24 * 60 * 60 * 1000); //differenza in giorni

------------------
Formattazione Date
------------------

Per formattare l'output degli oggetti Calendar si può utilizzare la classe
java.text.SimpleDateFormat .

SimpleDateFormat sdf =
new SimpleDateFormat("dd/MM/yyyy - HH:mm:ss");
System.out.println( sdf.format( data.getTime() ) );

Parsing Date
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy - HH:mm:ss");
String mydata = "02/03/2008";
Calendar c = (sdf.parse(myData)).getCalendar();



-------------------------
In una pagina JSP
-------------------------

<%@page import="java.util.GregorianCalendar"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSP Page</title>
</head>
<body>
<h1>Hello World!</h1>
<% GregorianCalendar d = new GregorianCalendar();%>
<%= "Oggi è il giorno "+ d.get(GregorianCalendar.DATE) +"/"+ (d.get(GregorianCalendar.MONTH)+1) %>

<% GregorianCalendar natale = new GregorianCalendar(2017,11,25);

long msec1 = d.getTimeInMillis();
long msec2 = natale.getTimeInMillis();
long diffDays = (msec2-msec1) / (24 * 60 * 60 * 1000); //differenza in giorni
%>


<%= "Mancano "+ diffDays + " giorni a Natale" %>

</body>
</html>



-------------------------
Riferimenti Bibliografici
-------------------------
• http://java.sun.com/j2se/1.5.0/docs/api/java/util/GregorianCalendar.html
• http://java.sun.com/j2se/1.5.0/docs/api/java/text/SimpleDateFormat.html

Corso Java Base - JCF
corso-java-base-2
Corso Java Base

Java Collection Framework

snippet code

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

public class List {

public static void main (String[] args) {



//primo array

String[] moto =

{

"Moto Guzzi V35 Imola",

"Yamaha Tenerè XTZ 600",

"Yamaha XT600",

"BMW K100RS",

"BMW R1150GS" };



//stampo primo array

System.out.println("Primo array");

for (String x: moto)

System.out.println(x);



//istanzio un oggetto di tipo list

List<String> lista1 = new ArrayList<String>();



//aggiungo a lista1 gli elementi di primo array: metodo add();

for(String x: moto)

lista1.add(x);



//secondo array

String[] motoVorrei =

{ "Suzuki GSR750", "Tenerè XTZ 600", "Honda NC750X" };



//stampo primo array

System.out.println("Secondo array");

for (String z: motoVorrei)

System.out.println(z);



//nuovo oggetto di tipo list

List<String> lista2 = new ArrayList<String>();



System.out.println("Aggiungo elementi a lista 2");



//add per aggiungere elementi

for(String y: motoVorrei)

lista2.add(y);



System.out.println("Stampo elementi a lista 2 usendo il metodo size() e get()");

//get per conoscere il valore dell'i-esimo elemento, size() metodo che restituisce la dimensione dell'oggetto

for (int i = 0; i<lista2.size();i++){

System.out.printf("%s \n", lista2.get(i));

}



System.out.println("Poi aggiungo lista2 a lista1 metodo addAll");



//addAll() : metodo per aggiungere tutti i valori dell'oggetto lista2 all'oggetto lista1

lista1.addAll(lista2);

System.out.println("Stampo la nuova Lista1");



for (int i = 0; i<lista1.size();i++){

System.out.printf("%s \n", lista1.get(i));

}



System.out.println("Lista1 modificata con tutti i valori di lista2 aggiunti");



//

for (int i = 0; i<lista1.size();i++){

System.out.printf("%s %s \n", i, lista1.get(i));

}



System.out.println("Lista2 è rimasta uguale: ");

//lista2=null;

for (int i = 0; i<lista2.size();i++){

System.out.printf("%s \t", lista2.get(i));

}



//metodo editlist

editlist(lista1,lista2);

System.out.println("confronto le stringhe e le modifico col metodo editlist");

for (int i = 0; i<lista1.size();i++){

System.out.printf("%s %s \n", i, lista1.get(i));

}



}



private static void editlist(Collection<String> lista1, Collection<String> lista2) {

Iterator<String> it = lista1.iterator();

while (it.hasNext()){

if (lista2.contains(it.next()))

it.remove();

}

}

}




/** JCF: alcuni metodi collection e interfaccia Iterator */



import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;



public class ListEstesa {



public static void main(String[] args) {



// primo array

String[] moto = { "1Guzzi V35 Imola", "2Tenerè XTZ 600", "3XT600",

"4BMW K100", "5BMW R1150 GS" };

// secondo array

String[] motoVorrei = { "6Suzuki GSR750", "7Tenerè XTZ 600",

"8Honda NC750X" };



// istanzio oggetto di tipo list

List lista1 = new ArrayList();

// nuovo oggetto di tipo list

List lista2 = new ArrayList();



// aggiungo elementi del primo array a lista1: metodo add();

for (String x : moto)

lista1.add(x);



// uso add per aggiungere elementi a lista 2

for (String x : moto)

lista2.add(x);

printme(lista1);

// addAll() : metodo per aggiungere tutti i valori dell'oggetto lista2

// all'oggetto lista1

lista1.addAll(lista2);



printme(lista1);

rimuoviDaLista(lista1, 3, 5);

printme(lista1);

reverseLista(lista1);



}



// stampare i valori

private static void printme(List l) {

System.out.println("metodo printme");

for (String a : l)

System.out.printf("%s \n", a);

System.out.println();

}



// rimuovere elementi

private static void rimuoviDaLista(List l, int from, int to) {

System.out.println("metodo rimuovi");

l.subList(from, to).clear();

}



// reverse list

private static void reverseLista(List l) {

System.out.println("metodo reverse");

ListIterator lista = l.listIterator(l.size());

while (lista.hasPrevious())

System.out.printf("%s \n", lista.previous());

}



}





/** JCF: convertire list in array e viceversa */



import java.util.Arrays;

import java.util.LinkedList;

public class Main {

public static void main (String[] args) {



String[] film = { "Pulp Fiction", "Le iene", "Kill Bill" };

LinkedList<String> thelist = new LinkedList<String>(Arrays.asList(film));



thelist.add("Django Unchained");

thelist.addFirst("Jackie Brown");



//riconverti ad array

film = thelist.toArray(new String[thelist.size()]);



for (String x: film)

System.out.printf("%s \n", x);



}



}





/** JCF: collections metodi sort() e overload con reverseOrder() */



import java.util.Arrays;

import java.util.Collections;

import java.util.List;





public class Main {



public static void main (String[] args) {





String[] film = { "Pulp Fiction", "Le iene", "Kill Bill" };

List lista1 = Arrays.asList(film);



//ordina coi metodi collections

Collections.sort(lista1);



for (String x: lista1)

System.out.printf("%s \n", x);



//overload del metodo, 2 parametri

//ordina coi metodi collections

Collections.sort(lista1, Collections.reverseOrder());



for (String x: lista1)

System.out.printf("%s \n", x);

}



}



Corso Java Base
corso-java-base
Corso Java Base

Appunti del corso Java Base - Introduzione alla programmazione a oggetti
Torino, marso-maggio 2014, Pier della Francesca, Corso di formazione aziendale
Come testo principale abbiamo adottato il Manuale di Java 7, di Claudio De Sio Cesari, edito da Hoepli
Programma del corso

Argomenti

Introduzione a Java


Introduzione

Compilazione ed esecuzione

Sintassi e programmazione strutturata

variabili e metodi

tipi di dati, array

operatori di controllo flusso


Sintassi e programmazione OO


Object Oriented fondamenti

Ereditarieta, Incapsulamento, Polimorfismo

sintassi e pratica OO

Accesso database

accesso a DB via JDBC



Object Relation Mapping

Eccezioni

Classe Exception

Try e catch

Generazione di eccezioni

Creazione di nuove eccezioni




Core libraries


collezioni e iteratori

input/output

gestione delle date, numeri complessi e formattazione

networking di base


Unità didattiche


Installazione ambiente di sviluppo

Introduzione linguaggio Java

Compilazione ed esecuzione

Compilazione ed esecuzione

Sintassi java

Basi della programmazione


variabili e metodi


Operatori di assegnazione, relazionali e booleani

Operatori aritmetici

Pre/post incremento e concatenazione stringhe

Variabili locali

Metodi

Il metodo Main ed i sottoprogrammi

Metodi di classe: La parola chiave Static

Passaggio dei parametri per riferimento e per valore

Modificatori

Gestione e importazione dei package


tipi di dati, array


Scope delle variabili

Tipi di dato primitivi

Caso particolare: la classe String

Casting

Input/Output utente

Array monodimensionali

Array multidimensionali


operatori di controllo flusso


Istruzione If-Else e operatore ternario

IF annidati

Istruzione Switch - case

Ciclo While

Ciclo Do-While

Ciclo For

Cicli annidati

Cicli infiniti


Object Oriented fondamenti


Labels, Break e Continue

Programmazione ad oggetti

La programmazione ad oggetti

Progettare una Classe

Istanziare un Oggetto: il costruttore

Variabili d’istanza e incapsulamento

Visibilità dei membri di una classe

Il reference This

Ereditarietà , Incapsulamento, Polimorfismo

La parola riservata null

EreditarietÃ

Il concetto di ereditarietÃ

Strutture ereditarie


Dalla teoria alla pratica: EreditarietÃ


La parola riservata super

La classe Object

Impedire l'ereditarietà : la parola riservata final

sintassi e pratica Object Oriented

Membri statici e membri dinamici

Polimorfismo

Overloading e Overriding

Binding dinamico

Casting con oggetti

Cast e instanceof

Interfacce, classi astratte e classi innestate

Interfacce

Ereditarietà e polimorfismo nelle interfacce

Classi astratte

Classi innestate

Classi anonime




accesso al DataBase via JDBC


Introduzione a JDBC

Convenzioni JDBC URL Naming

Gestione dei driver: il DriverManager

Gestione degli errori

Le SQLException

Supporto per i tipi di dati

Estensioni standard di JDBC

Connection Pooling

Object Relation Mapping

Gestione dei dati: JDBC

DataBase


Classe Exception


Eccezioni

Errori ed eccezioni

Il costrutto TRY-CATCH-FINALLY

Tipi di eccezione ed il costrutto Throws

Try e catch

Lanciare un’eccezione: il costrutto Throw

Eccezioni personalizzate

Generazione di eccezioni

Creazione di nuove eccezioni


collezioni e iteratori


Il Framework Collections

Framework Collections

Foreach ed Iterator

Implementazioni di Set e SortedSet

input/output

Implementazioni di List

Implementazioni di Queue

Implementazioni di Map e SortedMap

Tipi Generics


gestione delle date, numeri complessi e formattazione


Input/Output

Introduzione all’I/O: input da tastiera

Java.io: Leggere un file

Java.io: Scrivere su un file

networking di base

Java.io:Operazioni su file

Networking: Socket