Linguaggio Java - UniCam - Computer Science Division

Transcript

Linguaggio Java
(Base)
marzo 2000
Linguaggio Java
Ing. Thimoty Barbieri
1/92
So mmario
P ER C OMINCIARE .............................................................................5
SCRITTURA DEL SORGENTE.........................................................................................................................................................................6
COMPILAZIONE .............................................................................................................................................................................................7
ESECUZIONE ..................................................................................................................................................................................................8
VARIABILI......................................................................................................................................................................................................9
STRUTTURE DI CONTROLLO ......................................................................................................................................................................10
ARRAY..........................................................................................................................................................................................................11
STRINGHE.....................................................................................................................................................................................................12
CLASSI ED O GGETTI .......................................................................13
ESEMPIO .......................................................................................................................................................................................................14
ESEMPIO .......................................................................................................................................................................................................15
MODIFICATORI ............................................................................................................................................................................................16
COSTRUTTORI ..............................................................................................................................................................................................17
ESEMPIO COSTRUTTORI .............................................................................................................................................................................18
ESEMPIO INVOCAZIONE .............................................................................................................................................................................19
METODI ........................................................................................................................................................................................................20
PASSAGGIO PER VALORE ...........................................................................................................................................................................21
PASSAGGIO DI OGGETTI.............................................................................................................................................................................22
ESEMPIO DI PASS BY VALUE .....................................................................................................................................................................23
ULTERIORI COMMENTI ..............................................................................................................................................................................24
ULTERIORI COMMENTI ..............................................................................................................................................................................25
IL GARBAGE COLLECTOR..........................................................................................................................................................................26
IL GARBAGE COLLECTOR..........................................................................................................................................................................27
CLASSI NESTATE.........................................................................................................................................................................................28
CLASSI INNER..............................................................................................................................................................................................29
EREDITARIETÀ ................................................................................30
DIFFERENZA TRA OVERLOADING E OVERRIDING..................................................................................................................................31
USO DI PROTECTED .....................................................................................................................................................................................32
USO DEI COSTRUTTORI ..............................................................................................................................................................................33
LA CLASSE OBJECT .....................................................................................................................................................................................34
USO DI CLASSI ANONIME ...........................................................................................................................................................................35
CLASSI E METODI ASTRATTI......................................................................................................................................................................36
INTERFACCE ...................................................................................37
ESTENSIONE ATTRAVERSO LE INTERFACCE ............................................................................................................................................38
ESEMPIO DI ESTENSIONE CON INTERFACCE..............................................................................................................................................1
RISOLUZIONE DI CONFLITTI......................................................................................................................................................................40
G ESTIONE DELLE ECCEZIONI ........................................................41
Linguaggio Java
2/92
CREAZIONE DI ECCEZIONI.........................................................................................................................................................................42
LANCIO DI ECCEZIONI ................................................................................................................................................................................43
TRY , CATCH E FINALLY..............................................................................................................................................................................44
LA CLASSE S TRING .........................................................................45
CONVERSIONI DA ALTRI TIPI A STRINGA .................................................................................................................................................46
CONVERSIONE DA STRINGA A ALTRI TIPI................................................................................................................................................47
STRINGHE ED A RRAY DI CHAR..................................................................................................................................................................48
I THREAD ........................................................................................49
CREAZIONE DI THREAD .............................................................................................................................................................................50
CREAZIONE DI THREAD .............................................................................................................................................................................51
UN ESEMPIO DI THREAD............................................................................................................................................................................52
ESEMPIO (CONTINUA ) ................................................................................................................................................................................53
SINCRONIZZAZIONE....................................................................................................................................................................................54
ESEMPIO DI SINCRONIZZAZIONE..............................................................................................................................................................55
LOCK SU CODICE .........................................................................................................................................................................................56
WAIT .............................................................................................................................................................................................................57
CONDIZIONI DI USO DI WAIT ......................................................................................................................................................................58
NOTIFY E NOTIFYALL .................................................................................................................................................................................59
SCHEDULAZIONE.........................................................................................................................................................................................60
PRIORITÀ......................................................................................................................................................................................................61
SLEEP E YIELD..............................................................................................................................................................................................62
CONDIZIONE DI DEADLOCK ......................................................................................................................................................................63
TERMINAZIONE DI UN THREAD.................................................................................................................................................................64
ATTESA DI TERMINAZIONE DI THREAD....................................................................................................................................................65
ESEMPIO DI JOIN .........................................................................................................................................................................................66
RUNNABLE...................................................................................................................................................................................................67
I PACKAGE ......................................................................................68
PACKAGE - ESEMPIO..................................................................................................................................................................................69
USO DI J AVAD OC ............................................................................70
COMMENTI PER JAVA DOC.........................................................................................................................................................................71
TAG PER JAVADOC .....................................................................................................................................................................................72
ESEMPIO DI JAVADOC................................................................................................................................................................................73
UTILITÀ ...........................................................................................74
ENUMERATION ............................................................................................................................................................................................75
VECTOR........................................................................................................................................................................................................76
DICTIONARY................................................................................................................................................................................................77
HASHTABLE .................................................................................................................................................................................................78
RANDOM ......................................................................................................................................................................................................79
STRINGTOKENIZER.....................................................................................................................................................................................80
Linguaggio Java
3/92
I/O E N ETWORKING .......................................................................81
METODI STANDARD...................................................................................................................................................................................82
USO DI STREAM FILE (BYTE ORIENTED).................................................................................................................................................83
RANDOM A CCESSFILE ................................................................................................................................................................................84
NETWORKING..............................................................................................................................................................................................85
CREAZIONE DI UN SOCKET DI TRASMISSIONE........................................................................................................................................86
SCRITTURA SU SOCKET CLIENT................................................................................................................................................................87
SCRITTURA SU SOCKET CLIENT (2)..........................................................................................................................................................88
USO DI SOCKET SERVER............................................................................................................................................................................89
APERTURA STREAM PER SOCKET .............................................................................................................................................................90
LETTURA E STAMPA SU STREAM DEI SOCKET........................................................................................................................................91
PACKAGE S TANDARD .....................................................................92
Linguaggio Java
4/92
Per C ominciare
Java è un linguaggio ad oggetti puro.
Per lavorare e compilare sorgenti Java occorre installare il JDK
(Java Development Kit).
Il JDK contiene
I tool di compilazione e debugging
La JVM (Java Virtual Machine)
La JVM simula una piattaforma hardware in grado di compilare
il particolare compilato Java, denominato bytecode.
Pertanto, qualsiasi macchina che disponga di una JVM
installata è in grado di eseguire in modo corretto codice Java.
La JVM può anche essere compresa all'interno di un browser
internet. In questo modo è possibile eseguire codice mobile
(Applet).
Linguaggio Java
5/92
Scrittura del So rgente
I sorgenti Java sono file con estensione .java.
Ciascun file .java contiene il codice relativo ad una classe.
Listato di HelloWorld.java:
class HelloWorld {
public static void main(String[]args)
{
// Se si hanno problemi con questo,
// la situazione è critica
System.out.println("Hello World!");
}
}
Il codice Java è case sensitive.
Il nome del file .java deve coincidere con il nome della classe.
Linguaggio Java
6/92
Com pilazio ne
La compilazione avviene invocando da linea di comando il
compilatore java compreso nel JDK (javac):
> javac HelloWorld.java
Se tutto è corretto, viene creato un file con lo stesso nome e
l'estensione .class.
Questo file contiene il compilato bytecode eseguibile da
qualsiasi JVM su qualsiasi piattaforma.
La forza di Java sta nella sua portabilità.
Si compila una volta, si esegue su qualsiasi piattaforma con
JVM.
Linguaggio Java
7/92
Esecuzione
L'esecuzione può avvenire invocando la JVM:
> java HelloWorld
Per funzionare, la JVM si appoggia a delle librerie che vengono
consultate a runtime.
Queste librerie sono anch'esse dei .class raccolte in un unico file
compresso.
La variabile di ambiente CLASSPATH contiene l'elenco dei path a
tutte le .class di libreria o ai file compressi di libreria che la JVM
può utilizzare.
Impostazione tipica di CLASSPATH:
CLASSPATH =
.;c:\jdk1.2.2\lib\classes.zip;d:\devel\java\myclasses.jar
Linguaggio Java
8/92
V ariabili
Java dispone dei seguenti tipi primitivi:
boolean
char (16 bit unicode)
byte (signed int 8 bit)
short (signed int 16 bit)
int (signed int 32 bit)
long (signed int 64 bit)
float (floating point 32 bit)
double (floating point 64 bit)
Assegnazione:
int a = 5;
Confronto:
if (a == 5) …
Costanti:
static final double ? = 3.1416;
(Java lavora in Unicode)
Linguaggio Java
9/92
Strutture di Co ntrollo
Classiche strutture di controllo di flusso:
if (condizione)
{ true block }
else { false block }
for (init; condition; increment) { code }
while (condition) { block }
Incrementi: i++, i += 1, i = i + 1
Il blocco { code } delimita una zona di scoping, anche se non è
legato a nessuna struttura di controllo.
Linguaggio Java
10/92
Array
Gli array si numerano da zero, e sono una lista di elementi tutti
del medesimo tipo.
La dichiarazione usa le quadre, l'assegnazione di valori le
graffe.
Cards[] cards = new Card[DECK_SIZE];
int numbers = new int[];
numbers = { 1, 2, 3, 4, 5 };
int 3dpos[][][]; // array 3D
int unNumero = numbers[2]; // unNumero = 3
Metodi applicabili:
Array.length per conoscerne la lunghezza
Linguaggio Java
11/92
Stringhe
Il tipo non primitivo String consente di trattare le stringhe.
// costante esplicita
System.out.println("Java is cool");
// Matematica tra stringhe
String myName = "Petronius";
myName += "is my name.";
// alcuni metodi utili
int lunghstringa = myName.length();
myName.trim(); // taglia gli spazi in // testa
e in coda
// confronto case insensitive
if (myName.equalsIgnoreCase("Arbiter")
// confronto case sensitive
if (myName.equals("Arbiter"))
Linguaggio Java
12/92
C lassi ed Oggetti
Come i tutti i linguaggi ad oggetti, la classe descrive una
generica entità, mediante la definizione dei suoi metodi e dei
suoi attributi.
Da ciascuna classe vengono fatte derivare una o più istanze,
dette oggetti. Esse differiscono perché ciascuna istanza
conserva il proprio stato.
I metodi invocati su una determinata istanza hanno l'effetto di
modificare lo stato di quella determinata istanza.
L'istanzazione avviene mediante la parola new, che invoca il
costruttore, un particolare metodo con lo stesso nome della
classe.
Il punto referenzia la chiamata al metodo o al campo.
Linguaggio Java
13/92
Esempio
class Point {
public double x, y;
public
double
double
return
double distance(Point that){
xdiff = x – that.x;
ydiff = y – that.y;
Math.sqrt(xdiff^2+ydiff^2);
}
public void move(double x, double y) {
this.x = x;
this.y = y;
}
}
L'uso di this in Point.move disambigua il nome dei campi da
quello dei parametri formali del metodo.
Linguaggio Java
14/92
Esempio
L'utilizzo di questa classe ne prevede l'istanziazione:
Point p1 = new Point();
// il costruttore di questa classe è //
implicito
p1.x = 12.0;
// questo è lecito perché il campo è // public
p1.move(14.0, 15.0);
// invoca un metodo su p1
Point p2 = new Point();
p2.x = 14.0;
p2.y = 16.0;
// Invoca il calcolo della distanza
p1.distance(p2);
Linguaggio Java
15/92
Mo dificato ri
public rende un metodo o un campo accessibili a tutte le altre
classi
private rende un metodo o un campo accessibile solo a metodi
della medesima classe
protected rende un metodo o un campo accessibile solo a
metodi della medesima classe o di una sottoclasse nel
medesimo package
private protected rende metodi e campi accessibili solo alla
medesima classe e sua sottoclasse
friendly rende il campo e metodo accessibili ad altre classi
dello stesso package, ma non alle sottoclassi
final rende il campo non modificabile
static rende il campo o il metodo di classe e non di istanza
(vengono messi "a comune")
Se non si specifica nessun modificatore, la visibilità è all'interno
di tutte le classi (e sottoclassi) dello stesso package.
Linguaggio Java
16/92
Co strutto ri
Ogni oggetto appena creato ha uno stato iniziale. I costruttori
consentono di avere una inizializzazione di tipo complesso,
perché sono eseguiti all'atto dell'istanziazione dell'oggetto.
Se non si specifica nessun costruttore, la classe è detta no-arg
ed ha un costruttore implicito vuoto.
È possibile fare un overloading del costruttore specificandone
più di uno, tutti con segnature diverse. Quello invocato
dipende dall'utilizzo della new.
I costruttori sono utili per assicurarsi che le inizializzazioni di
stato siano fatte in modo corretto, scaricando di questa
responsaibilità l'utilizzatore della classe, che non è tenuto a
conoscere i campi della classe (information hiding).
Linguaggio Java
17/92
Esem pio Co strutto ri
class Body {
public long idNum;
public String name = "(unnamed)";
public Body orbits = null;
private static long nextID = 0;
// costruttore no.arg
Body() {
IdNum = nextID++;
}
// overload del costruttore
Body(String bodyName, Body orbitsAround) {
this();
name = bodyName;
orbits = orbitsAround;
} }
Linguaggio Java
18/92
Esempio Invocazione
Body sun = new Body();
sun.name = "Sol" // possibile ma viola
// il principio di info hiding
Body earth = new Body();
earth.name = "Earth";
earth.orbits = sun; // passa un Body
// utilizzando il nuovo costruttore
// rispettiamo information hiding:
Body sun = new Body("Sol", null);
Body sun = new Body("Earth", sun);
Linguaggio Java
19/92
Meto di
Ciascuna classe mette a disposizione metodi invocabili con
l'operatore . sull'istanza, a meno che non si tratti di metodi
statici.
I metodi statici sono invocati con il loro percorso di libreria (ad
es. java.Math.sqrt(x)).
I metodi accettano parametri in ingresso e possono ritornare
un valore. Occorre sempre specificare il valore ritornato:
void
nessun valore ritornato
<type> altro tipo di valore ritornato
Metodi non void devono obbligatoriamente terminare in ogni
caso con un return corrispondente al tipo di ritorno dichiarato.
Inoltre è possibile associare ai metodi gli opportuni modificatori
di visibilità.
Linguaggio Java
20/92
Passaggio per Valo re
Tutti i parametri sono passati ai metodi per valore.
In Java non esiste in modo esplicito il concetto di puntatore,
che il programmatore non può utilizzare direttamente.
I valori delle variabili parametro in un metodo sono copie dei
valori usati come argomenti all'atto dell'invocazione. Il metodo
dunque riceve una copia del valore dell'argomento passato.
Quando si istanziano oggetti, l'identificatore a sinistra della
new riceve un valore che rappresenta il riferimento all'oggetto
all'interno dello heap.
Linguaggio Java
21/92
Passaggio di O ggetti
Passando un oggetto come parametro, ciò che viene passato
non è l'oggetto ma il valore del riferimento.
In questo modo all'interno del metodo si può modificare a
quale oggetto il parametro si riferisce senza influenzare il
riferimento che è stato ricevuto nel passaggio.
Tuttavia, se si cambia qualsiasi campo dell'oggetto a cui il
valore si riferisce, o se se ne invocano i metodi per cambiarne
lo stato, l'oggetto viene cambiato per ogni parte del
programma che contiene un riferimento ad esso.
Linguaggio Java
22/92
Esempio di Pass by V alue
class PassRef {
public static void main(String[] args) {
Body sirius = new Body("Sirius", null);
System.out.println("bef:"+sirius);
commonName(sirius);
System.out.println("aft:"+sirius);
}
public static void commonName(Body bodyRef)
{
bodyRef.name = "Dog Star";
bodyRef = null;
}
}
bef: 0 (Sirius)
aft: 0 (Dog Star)
Linguaggio Java
23/92
Ulterio ri Co mmenti
Diffidate da coloro che sostengono che Java passa i parametri
by reference (per riferimento). Java passa PER VALORE IL
RIFERIMENTO, ed è l'unica modalità di passaggio in Java.
Passando per riferimento, l'argomento passato alla funzione è
riferimento diretto al valore originale e non una copia.
Se la funzione modifica dunque il parametro, il valore viene
cambiato anche nel codice chiamante, perché la funzione e il
codice chiamante usano lo stesso slot di memoria.
Con questo meccanismo, la linea bodyRef = null avrebbe
l'effetto di cancellare l'oggetto sirius.
Linguaggio Java
24/92
Ulterio ri Co mmenti
Invece il passaggio per valore del riferimento impedisce alla
funzione chiamata di distruggere l'oggetto utilizzato dalla
chiamante.
Poiché vengono fatte DUE COPIE dello stesso riferimento, che
punta allo stesso oggetto, i cambiamenti fatti passando
attraverso uno dei due riferimenti sono visibili sia alla
chiamante che al chiamato, ma la distruzione di uno dei due
valori del riferimento non impatta sull'altra copia del
riferimento.
Linguaggio Java
25/92
Il Garbage Co llecto r
Quando un oggetto istanziato, che occupa memoria nello
heap, non è più raggiungibile da alcuna porzione del codice
(tutti i riferimenti ad esso sono a null), lo spazio che occupa
viene recuperato.
Il programmatore non ha alcun controllo su questo: la
liberazione della memoria viene eseguita in background da un
apposito thread detto garbage collector.
In questo modo si elimina il problema delle dangling
references, vale a dire non è possibile che il programmatore
cancelli oggetti a cui parti del programma si riferiscono ancora.
Linguaggio Java
26/92
Il Garbage Co llecto r
Anche se Java fa molto lavoro per il programmatore, tuttavia è
buona pratica programmare in modo ordinato, mettendo a null
tutti gli oggetti di cui non si ha bisogno.
Il metodo finalize() in un oggetto viene eseguito appena prima
che il garbage collector si inneschi per cancellare questo
oggetto.
La resurrection (autoinstanziazione da dentro la finalize) è
sconsigliata.
Linguaggio Java
27/92
Classi nestate
È possibile definire una classe all'interno di una classe,
ottenendo classi annidate.
Questa tecnica è utile per rappresentare strutture fortemente
correlate tra loro.
Spesso le classi annidate sono statiche (hanno significato
analogo ad uno struct del C in questo senso):
public class BankAccount {
private long number;
private long balance;
public static class Permissions {
public boolean canDeposit,
canWithdraw,
canClose;
} }
Ad esempio:
oneBankAccount.Permissions.canDeposit = true;
Linguaggio Java
28/92
C lassi inner
Se la classe annidata non è statica, essa è detta inner.
È possibile indicare questa sottoclasse con un this nestato.
public class BankAccount {
public class Action {
private String act;
. . .
return BankAccount.this.act;
}
Action lastAct = this.new Action()
}
Linguaggio Java
29/92
Ereditarietà
Tutte le classi Java implicitamente sono classi derivate da una
superclasse Object, che contiene metodi propri di tutti gli
oggetti Java in quanto tali.
Il tipo Object può dunque essere usato in polimorfismo con
qualsiasi oggetto Java.
L'ereditarietà viene indicata esplicitamente mediante la parola
chiave extends.
class Pixel extends Point {
Color color;
public void clear() {
super.clear();
color = null;
} }
Linguaggio Java
30/92
D ifferenza tra Overloading e Overriding
Porre attenzione alla differenza:
l'overloading di metodi consiste nello specificare più volte uno
stesso metodo in una classe, tutti con segnature differenti.
class Point {
int x, y;
Point() { x=0; y=0; }
Point (int initx, int inity)
{ x = initx; y = inity; }
public void clear() { x=0; y=0; } }
l'overriding consiste nel re-implementare un metodo ereditato
dalla superclasse nella sottoclasse, con il vincolo di
mantenerne identica la segnatura.
Class Pixel extends Point {
int color;
public void clear()
{ super.clear(); color=0; } }
Linguaggio Java
31/92
Uso di pro tected
Dessert
Torta
Pasticcino
Crostata
Un identificatore protected può essere acceduto da una classe
tramite un riferimento che abbia almeno lo stesso tipo o
sottotipo della classe. Ad esempio:
La classe Dessert ha un campo protected int calorie; esso
viene ereditato sia da Torta che da Pasticcino.
Tuttavia il codice di Torta può accedere a calorie solamente
con un riferimento di tipo Torta o di tipo di una sottoclasse
(Crostata).
I campi protetti di una classe non possono essere acceduta al
di fuori della gerarchia di ereditarietà cui appartiene la classe
di accesso.
Linguaggio Java
32/92
Uso dei C ostruttori
Il costruttore di una classe che estende una superclasse ricade
nelle seguenti regole:
È possibile utilizzare super() per invocare il costruttore noarg della superclasse. Si può anche invocare super() con i
parametri per utilizzare un costruttore diverso in overload.
Se non usa esplicitamente una super(), viene invocato
implcitamente il costruttore super() no-arg della
superclasse.
Se la superclasse non dispone di un costruttore no-arg
esplicito, bisogna invocare esplicitamente un altro
costruttore di superclasse
In alternativa si può invocare un altro costruttore della
stessa classe (con this()).
In ogni caso l'uso di super() deve essere alla prima linea di
codice del costruttore della sottoclasse.
Linguaggio Java
33/92
La classe Object
Tutte le classi che direttamente o indirettamente ereditano da
Object dispongono dei seguenti metodi:
boolean equals(Object obj)
consente di confrontare per uguaglianza due oggetti
public int hashCode()
Ritorna un codice ID unico da usare nelle tabelle per
distringuere tra loro gli oggetti
protected Object clone()
Ritorna un clone dell'oggetto
public final Class getClass()
Ritorna un oggetto Class contenente la classe cui
appartiene l'oggetto
protected void finalize()
Viene invocato appena prima di una cancellazione quando
l'oggetto viene selezionato per la garbage collection
Questi metodi possono essere overridati (ove non final).
Linguaggio Java
34/92
Uso di classi anonime
È possibile definire classi 'al volo', senza assegnare loro
esplicitamente un nome, ma usandole come 'oggetti passanti'
di ritorno. Queste classi sono dette anonime:
public DataSet createSet() {
return new DataSet() {
private int numrec = 0;
private String setname = "";
public String whichName() {
return setname;
}
}
Linguaggio Java
35/92
Classi e meto di astratti
È possibile creare classi in cui alcuni metodi sono implementati,
altri invece non lo sono: questo perché la classe non è
sufficientemente specifica, e risulta meglio affidare
l'implementazione a sottoclassi di questa classe.
I metodi non implementati sono detti abstract. Una classe che
contiene un metodo abstract è essa stessa detta abstract.
Le classi che ereditano da una classe abstract devono
implementare il metodo astratto della superclasse.
abstract class Benchmark {
abstract void benchmark();
public long repeat(int count) { . . .}
}
class MethodBenchmark extends Benchmark {
void benchmark() { . . .}
}
Linguaggio Java
36/92
Interfacce
Le interfacce sono un modo per dichiarare una struttura basata
solo su metodi astratti e relative costanti.
Essa è il risultato della pura progettazione, a prescindere
dall'effettiva implementazione Java.
Tipicamente è il risultato che il progettista passa al
programmatore, per assicurarsi che il programmatore realizzi il
modulo esattamente secondo le specifiche di progetto.
L'uso dell'interfaccia consente di aggirare il modello ad
ereditarietà singola, ottenendo di ereditare campi e metodi
anche da più di una classe.
Linguaggio Java
37/92
Estensio ne attraverso le interfacce
Per evitare i problemi dati dall'ereditarietà a diamante
(conflitto tra identificatori con il medesimo nome), Java evita
formalmente l'uso di ereditarietà multipla.
Tuttavia il modello a ereditarietà singola impedisce di scrivere
codice molto utile (ad es. un Applet che sia anche un Thread
deve ereditare sia dalle classi Applet che dalla classe Thread!)
Ciascuna classe può dunque implementare un'interfaccia ed
estendere una classe.
A sua volta, ogni interfaccia può estendere una classe.
Se dunque una classe implementa un'interfaccia che estende
un'altra classe, ecco che la prima classe ha un risultato simile a
una doppia ereditarietà.
Linguaggio Java
38/92
Esempio di Estensione co n Interfacce
W
Y
X
Z
Questa struttura crea in Java un'ereditarietà a diamante:
interface W { }
interface X extends W { }
class Y implements W { }
class Z extends Y implements X { }
Linguaggio Java
39/92
Riso luzio ne di C onflitti
Come dunque si risolvono i conflitti in un'ereditarietà a
diamante ottenuta in questo modo?
Se i metodi in X e Y hanno stesso nome ma segnature
diverse, Z avrà entrambi i metodi in overload
Se i metodi in X e Y hanno stesso nome e stesse
segnature, con pari valore ritornato, Z ha un unico metodo
con quella segnatura.
Se nome e segnature sono identiche e il tipo ritornato è
diverso, non è possibile che Z estenda/implementi sia X che
Y.
Se i metodi in X e Y differiscono solo per il tipo di eccezione
che lanciano, occorre fare in modo che le eccezioni lanciate
siano le stesse sia per X che per Y
Per gli identificatori si disambigua usando il full qualified
name: X.identif e Y.identif.
Linguaggio Java
40/92
Gestione delle Eccezioni
Le eccezioni costituiscono un comodo meccanismo per
individuare il sorgere di errori a run-time e specificare il modo
con cui essi devono essere trattati, senza fermare l'esecuzione.
L'insorgere di un errore è detto eccezione.
È possibile 'avvisare' il codice di 'stare in guardia' per il
verificarsi di una certa eccezione. Se questo accade, il codice
lancia l'eccezione.
L'eccezione deve venire catturata da una porzione di codice
apposito, che si comporta in modo da correggere la situazione
che ha portato al lancio dell'eccezione.
Questo sistema consente di scrivere codice più nitido, che non
interrompe continuamente il flusso naturale di istruzioni di un
algoritmo.
Linguaggio Java
41/92
C reazione di Eccezio ni
Le eccezioni sono considerabili come oggetti.
Per definire un tipo di eccezione, occorre creare una classe che
estende dalla superclasse Exception. È possibile definire campi
e metodi dell'oggetto eccezione lanciato dal codice che ha
incontrato un errore.
public class NoSuchAttributeException extends
Exception {
public String attrName;
NoSuchAttributeException(String name) {
Super("No attribute found!");
attrName = name;
}
}
Linguaggio Java
42/92
Lancio di Eccezioni
Quando si implementa un metodo, se esiste la possibilità che
esso lanci un'eccezione che non sia derivata da
RuntimeException o Error (che sono lanciate di default),
occorre dichiararlo esplicitamente nella segnatura del metodo
mediante la specifica throws.
Questo metodo deve specificare al suo interno quando
l'eccezione va lanciata, mediante il comando throw.
public void replaceValue(String name, Object
newValue) throws NoSuchAttributeException {
Attr attr = find (name);
if (attr == null)
throw new
NoSuchAttributeException(name);
attr.setValue(newValue);
}
Linguaggio Java
43/92
try, catch e finally
La struttura di controllo e raccolta di eccezioni è la seguente:
try {
codice che potrebbe lanciare un'eccezione
} catch (tipodieccezione ident1) {
codice che gestisce quel tipo di eccezione
} catch (tipodieccezione ident2) {
codice che gestisce un altro tipo di eccezione
} finally {
codice finale che viene eseguito in ogni caso
}
L'utilizzo di certi metodi richiedono obbligatoriamente che
vengano incapsulati dentro una try/catch (I/O, etc…)
Linguaggio Java
44/92
La classe String
Le stringhe sono di grande utilizzo, ed in Java sono
rappresentate mediante una classe a parte, dotata di diversi
costruttori e di vari metodi di grande utilità.
È possibile anche usare una sorta di "aritmetica" di stringhe
usando gli operatori + e += overloadati sulla classe stringa.
Alcuni tra i metodi più utili:
indexOf(char ch)
indexOf(char ch, int start)
indexOf(String str)
indexOf(String str, int start)
lastIndexOf(…) (con le 4 medesime segnature)
equals(String str)
equalsIgnoreCase(String str)
length()
startsWith(String prefix) / endsWith(String suffix) . . .
Linguaggio Java
45/92
Co nversioni da altri tipi a Stringa
Spesso è necessario convertire una Stringa in un altro o
viceversa per il trattamento dell'informazione:
Da un Tipo al Tipo Stringa:
boolean: String.valueOf(boolean)
byte:
String.valueOf(int)
short:
String.valueOf(int)
int:
String.valueOf(int)
long:
String.valueOf(long)
float:
String.valueOf(float)
double: String.valueOf(double)
Morale: si usa sempre il metodo valueOf (molto overloadato)
della classe Stringa.
Linguaggio Java
46/92
Co nversio ne da Stringa a altri tipi
Al contrario, occorre utilizzare i metodi di conversione messi a
disposizione dal tipo di destinazione.
Alcuni di questi metodi sono statici delle classi wrapper e di
facile invocazione. Per i metodi non statici si può utilizzare
un'istanza creata appositamente.
boolean:
new Boolean(String).booleanValue()
byte:
Byte.parseByte(String, int base)
short:
Short.parseShort(String, int base)
int:
Integer.parseInt(String, int base)
long:
Long.parseLong(String, int base)
float:
new Float(String).floatValue()
double:
new Double(String).doubleValue()
Se la base non è indicata, si intende la conversione di numeri
in base dieci.
Linguaggio Java
47/92
Stringhe ed Array di char
Una stringa può essere rappresentata come un array di char.
Questo può facilitare l'implementazione di alcuni metodi.
Esistono metodi per ricavare l'array da una Stringa, e per
creare un oggetto String da un array:
Da Stringa ad array:
String from = "Una Stringa"
char[] arraydichars = from.toCharArray()
Il contrario:
int len = chars.length();
String nuovaStringadaArray = new String(chars,
0, len)
Linguaggio Java
48/92
I Thread
Spesso nei programmi si segue una sola linea di esecuzione,
all'interno di un processo.
I sistemi multithreaded consentono di suddividere un processo
in più "parti" dette thread. Ciascun thread ospita una separata
linea di esecuzione, che evolve parallelamente alle altre.
Questo parallelismo (concorrenza) consente la condivisione di
dati in memoria: fornisce sia grande potenza e versatilità e
richiede cautela – possono crearsi situazioni di stallo
(deadlock) o di corsa critica (race conditions).
Linguaggio Java
49/92
Creazio ne di Thread
Un thread si definisce con un'istanza della classe Thread:
Thread worker = new Thread()
Successivamente il thread si configura, impostandone ad es. la
priorità.
Invocando il suo metodo start() si verifica uno spawn del
nuovo thread, e ne comincia l'esecuzione.
Il codice eseguito è quello contenuto nel metodo run().
Quando si esce dal metodo run(), il thread viene terminato.
Linguaggio Java
50/92
Creazio ne di Thread
Di default run() ha un'implementazione vuota, quindi occorre
definire in generale una classe che eredita da Thread e che fa
un override quantomeno di run() perché il Thread faccia
qualcosa di interessante.
I metodi stop, interrupt, suspend, consentono di controllare
l'esecuzione del thread (arrestarlo, interromperlo,
sospenderlo).
Il metodo stop solitamente non è sufficiente.
È buona norma porre a null l'identificatore che ospita il thread
per farlo uccidere il prima possibile dal Garbage Collector.
Il metodo sleep consente di inserire dei cicli d'attesa per
privilegiare un Thread rispetto ad un altro.
Linguaggio Java
51/92
Un Esem pio di Thread
public class PingPong extends Thread {
private String word;
private int delay;
public PingPong(String whatToSay, int
delay) {
word = whatToSay;
this.delay = delay;
}
public void run () {
try {
for (;;) {
System.out.print(word);
Sleep(delay);
}
} catch (InterruptedException e) {
return;
}
}
Linguaggio Java
52/92
Esem pio (continua)
public static void main(String[] args)
{
// Lancia i due thread e dimostra
// che si eseguono in parallelo
new PingPong("ping", 33).start();
new PingPong("PONG", 100).start();
}
}
Linguaggio Java
53/92
Sincro nizzazione
In programmazione concorrente esiste la possibilità che due
thread tentino di modificare lo stato di un medesimo oggetto.
Questo potrebbe causare delle incosistenze.
Utilizzando dei metodi dichiarati sincronizzati, viene posto un
blocco (lock) su quell'oggetto, che viene riservato al detentore
del lock fino a che esso non lo rilascia esplicitamente.
In questo modo non è possibile che due thread utilizzino
concorrentemente un oggetto.
L'altro thread deve attendere che il primo rilasci il blocco.
Il blocco si considera per thread. Se un thread che detiene già
un blocco deve utilizzare un altro metodo sincronizzato
sull'oggetto, può farlo perché detiene il lock.
Linguaggio Java
54/92
Esempio di Sincronizzazio ne
Ad esempio due thread che si occupano di aggiornare due
scritture contabili devono prevedere che il metodo di lettura e
quello di scrittura siano sincronizzati per garantire l'esattezza
degli stati.
class Account {
private double balance;
public Account(double initialDeposit) {
balance = initialDeposit;
}
public synchronized double getBalance() {
return balance;
}
public synchronized void deposit(double
amount) {
balance += amount;
}
}
Linguaggio Java
55/92
Lo ck su codice
È possibile all'interno di metodi non esplicitamente sincronizzati
richiede un lock su un oggetto e eseguirvi delle operazioni con
la garanzia che nel frattempo nessun altro thread modifichi
l'oggetto.
È sufficiente usare synchronized specificando l'identificatore
dell'oggetto da lockare, seguito dal blocco di codice da
eseguire durante il lock:
public static void abs(int[] values) {
synchronized (values) { //locka l'array per
// modificarlo
for(int i=0;i<values.length;i++) {
if (values[i]<0) values[i] = values[i];
}
} // chiude il blocco su cui acquisire il
// lock
}
Linguaggio Java
56/92
wait
È possibile coordinare tra loro i Thread usando delle condizioni
di attesa e di sblocco a comune.
wait mette in attesa un thread fino a che la condizione di
attesa non viene soddisfatta.
Quando questo accade, altri thread utilizzano notify o notifyAll
per comunicare al thread in attesa di proseguire.
synchronized void doWhenCondition() {
while (!condition) wait();
. . . codice da eseguire a condizione
avverata . . .
}
Linguaggio Java
57/92
Co ndizioni di uso di wait
Il blocco di sospensione per wait deve essere sincronizzato:
altrimenti lo stato dell'oggetto non è garantito stabile e
qualche altro oggetto potrebbe alterare la condizione di attesa
creando effetti non voluti.
wait ha l'effetto di sospendere il thread e nello stesso tempo
(atomicamente) di rilasciare il blocco del synchronize. Questo
consente agli altri oggetti di modificare la condizione di
sospensione, ma senza creare una corsa critica.
(Essa si verificherebbe se si riceve una notifica dopo il rilascio
del blocco ma prima della sospensione del thread se non
eseguite atomicamente: la notifica non avrebbe effetto sul
thread che sarebbe comunque sospeso).
La condizione va sempre in un loop: infatti il thread potrebbe
ricevere una notifica per una condizione che non gli compete,
ed in questo caso deve ciclare e ripetere lo stato di
sospensione.
Linguaggio Java
58/92
notify e notifyA ll
Costituiscono la controparte del thread in attesa col wait.
Notify notifica un solo thread (scelto random), notifyAll notifica
tutti i thread in wait, che verificano la condizione.
Se la condizione è soddisfatta, escono dal wait (incapsulato in
una while condizionata). Quasi sempre si usa la notifyAll.
synchronized void changeCondition() {
. . . cambia i valori della condizione . .
.
notifyAll();
}
Per gli stessi motivi della wait, occorre acquisire un lock per
modificare lo stato della condizione in modo stabile.
Linguaggio Java
59/92
Schedulazio ne
Esiste una 'preferenza' nella scelta dei thread che sono fatti
girare con un maggior tempo macchina.
Questa scelta si riflette nella priorità: thread con maggiore
priorità sono eseguiti con un maggior tempo macchina rispetto
a quelli a bassa priorità.
Conviene tenere a bassa priorità thread che devono rimanere
continuamente in esecuzione: in caso contrario essi
utilizzerebbero troppe risorse.
Questo impedirebbe a thread che devono attivarsi ogni tanto
per dare risposte pronte di funzionare (esempio la raccolta di
input dall'utente).
Linguaggio Java
60/92
Priorità
setPriority consente di impostare una priorietà a
MIN_PRIORITY, MAX_PRIORITY, NORM_PRIORITY.
Un thread inizialmente riceve la stessa priorità del thread che
l'ha generato.
getPriority restituisce la priorità di un thread.
Quando un thread viene interrotto, comincia l'esecuzione di un
altro thread con la stessa priorità.
Tutti i thread con la priorità massima verranno "prima o poi"
eseguiti.
I thread a priorità più basse vengono eseguiti quando gli altri
thread sono sospesi o bloccati perché stanno eseguendo un
metodo "bloccante".
Linguaggio Java
61/92
sleep e yield
Mediante sleep(long millis) è possibile impostare una
sospensione del numero di millisecondi (circa) specificato, in
modo da consentire ad altri thread di assumere la priorità.
Mediante yield() si cede l'esecuzione prioritaria ad altri thread
che possono essere messi in esecuzione. Lo schedulatore di
thread sceglie uno dei thread.
Non esiste un ordine garantito di esecuzione dei thread, la cui
gestione è diversa a seconda della configurazione della
macchine e del sistema operativo usato.
L'unica assunzione è che "prima o poi" tutti i thread hanno
occasione di essere eseguiti.
Linguaggio Java
62/92
Co ndizione di Deadlock
Ogniqualvolta si hanno almeno due thread e due lock
incrociati, può formarsi una situazione di stallo (deadlock), in
cui ciascun thread aspetta che l'altro rilasci il lock per
proseguire.
In questo 'abbraccio mortale' l'esecuzione non si trova più in
condizione di proseguire.
Il programmatore è responsabile di non creare oggetti e
situazioni di lock che formino situazioni di stallo.
Linguaggio Java
63/92
Terminazio ne di un Thread
In generale la vita di un thread termina quando l'esecuzione
esce dal metodo run().
Questo è il metodo più pulito, coadiuvato da un'esplicita
riassegnazione del Thread a null.
Esistono tuttavia altri modi di terminare un thread:
usando il metodo interrupt() si manda un segnale di
interruzione ad un thread.
Questo segnale può essere raccolto con il metodo
isInterrupted() ed usato per fermare il thread, ad esempio
incapsulando il run() in questo modo:
while (!isInterrupted()) { . . . }
Linguaggio Java
64/92
Attesa di terminazione di thread
È possibile attendere la fine di un thread con il metodo join().
La sua invocazione dopo il lancio di un thread arresta il
chiamante fino a che il thread di riferimento non termina.
Se il thread di riferimento termina prima che il chiamante usi la
join(), join ritorna immediatamente.
In questo modo è possibile creare una forma di coordinamento
tra chiamante e thread eseguiti.
Linguaggio Java
65/92
Esempio di Join
class ShowJoin {
public static void main(String args[]) {
CalcThread calc = new CalcThread();
calc.start();
doSomethingElse();
try {
calc.join();
System.out.println("calc
terminato");
} catch (InterruptedException e) {
System.out.println("interrupted.");
}
}
Linguaggio Java
66/92
Runnable
In situazioni in cui la parola extends è preziosa per estendere
da qualche altra classe, ma serve comunque creare un Thread,
si implementa da Runnable.
L'oggetto Runnable viene passato al costruttore di Thread
apposito per creare un Thread.
class RunPingPong implements Runnable {
. . .
public static void main(String args[]) {
Runnable ping = new RunPingPong("ping",33);
Runnable pong = new RunPingPong("PONG",
100);
// chiama il costruttore Thread che riceve
Runnable
new Thread(ping).start();
new Thread(pong).start();
} }
Linguaggio Java
67/92
I Package
Progetti Java complessi possono avere un elevato numero di
classi.
Può essere necessario organizzare queste classi in gruppo detti
package.
Essi possono essere strutturati ad albero: questa struttura si
riflette nel file system mediante l'albera della directory in cui
sono disposte le classi.
Il package va dichiarato in testa ad ogni sorgente
appartenente al package usando l'istruzione package <nome
package>.
Linguaggio Java
68/92
Package - Esempio
Ad esempio dodici classi che fanno parte del package test
andranno salvate nella directory test.
L'esecuzione della classe principale (ad es. runme.class) va
effettuata fuori dalla directory test in questo modo:
?? java test.runme
Ciascun sorgente .java deve iniziare come prima linea in
questo modo:
package test;
I package possono essere importati da altre classi fuori dal
package mediante la clausola import.
I package sono di riferimento per lo scoping dei modificatori.
Linguaggio Java
69/92
Uso di JavaDo c
La documentazione ed i commenti all'interno del codice sono
un dovere preciso del programmatore.
JavaDoc è un utility del JDK che consente di generare delle
pagine html di riferimento in stile Documentazione API da
utilizzare per la consultazione.
È sufficiente digitare
?? javadoc <nome sorgente java>
Per generare gli html di riferimento corrispondenti al codice.
Linguaggio Java
70/92
Co mmenti per JavaD oc
Sono parsati da JavaDoc tutti i commenti che iniziano con /**
e terminano con */.
Questi commenti devono essere posti prima della segnatura
del metodo cui si riferiscono o della classe o identificatore cui
si riferiscono.
All'interno dei commenti è possibile inserire tag HTML che
verranno interpretati dal browser quando si consultano le
pagine generate
Possono essere inoltre usati dei tag speciali (preceduti da @)
allo scopo di inserire informazioni dinamiche aggiuntive.
Linguaggio Java
71/92
Tag per JavaDoc
@see
riferimento ad altro link
@param
parametri di ingresso del metodo
@return
parametro di uscita del metodo
@exception
eccezioni lanciate dal metodo
@deprecated
marca il metodo come deprecato
@author
indica l'autore del metodo/classe
@version
indica la versione della classe
@since
specifica la versione di prima apparizione
Linguaggio Java
72/92
Esem pio di JavaDo c
/**
* Questo metodo serve come esempio
* <H1> È un metodo molto bello!</H1>
* @author dott. Mario Rossi
* @since 1.0
* @version 1.1
*/
public void TestMethod() {
...
}
Nella pagina html apparirà una voce TestMethod con
l'opportuno commento e le specifiche indicate.
Linguaggio Java
73/92
Utilità
Le API Java forniscono alcuni classi interessanti di grande
utilità nella programmazione, raccolte nella libreria java.util.*.
Fra queste:
Enumeration
Vector
Hashtable
Date
Random
StringTokenizer
Linguaggio Java
74/92
Enumeration
Enumeration è un'interfaccia che consente di gestire scansioni
lineari lungo liste di valori.
Mette a disposizione due metodi:
boolean hasMoreElements()
ritorna true se la lista ha altri elementi da scandire
Object nextElement()
Ritorna l'elemento successivo nella lista.
Utilizzo tipico:
Hashtable table;
Enumeration e = table.elements();
while (e.hasMoreElements())
doSomethingWith(e.nextElement());
Linguaggio Java
75/92
Vecto r
La classe Vector consiste un metodo comodo di impostare
array di oggetti in modo dinamico, molto meglio con gli array
normali.
addElement(Object obj)
aggiunge l'oggetto come ultimo elemento del vettore
insertElementAt(Object obj, int index)
aggiunge l'oggetto alla posizione index
setElementAt(Object obj, int index)
imposta l'oggetto alla posizione index
removeElementAt(int index)
rimuove l'elemento alla posizione index
removeAllElements()
svuota l'array
elementAt(int index)
ritorna l'elemento alla posizione index
isEmpty() . . . etc. etc.
Linguaggio Java
76/92
Dictionary
Dictionary è un interfaccia che implementa una matrice a
doppia entrata, con una colonna per le chiavi di ricerca ed una
per i contenuti.
Essa viene implementata dalla classe Hashtable.
I metodi previsti da Dictionary sono:
Object put(Object key, Object element)
Inserisce in dizionario una coppia chiave di ricerca –
elemento
Object get(Object key)
Ritorna l'oggetto legato alla chiave chiesta
Object remove(Object key)
Rimuove l'oggetto legato alla chiave
Enumeration keys()
Ritorna l'enumerazione delle chiavi presenti in dizionario
Enumeration elements()
Ritorna l'enumerazione degli elementi in dizionario
Linguaggio Java
77/92
Hashtable
Hashtable implementa effettivamente l'interfaccia Dictionary
aggiungendo altri utili metodi:
boolean containsKey(Object key)
vero se la chiave richiesta esiste
boolean contains(Object element)
vero se l'elemento richiesto esiste
void clear()
svuota l'hashtable
Linguaggio Java
78/92
Rando m
Consente di generare numeri casuale a partire da un seme.
Random() o Random(seed) costruisce l'oggetto per generare i
numeri casuali.
nextInt / nextLong / nextDouble … generano un numero
casuale del tipo richiesto.
Linguaggio Java
79/92
StringTokenizer
Una classe utilissima che consente di separare una stringa in
parti (token) dato un separatore a richiesta. Ottimo per
"parsare" linee di comando.
StringTokenizer(String str, String delim)
Crea un tokenizer sulla stringa richiesta considerando il
delimitatore considerato.
boolean hasMoreTokens()
ritorna true se ci sono altri token nella stringa
String nextToken()
ritorna il token successivo nella stringa
int countToken()
conta i token presenti nella stringa.
Linguaggio Java
80/92
I/O e Netw orking
Le classi di I/O utilizzano il concetto di stream, o flusso di dati.
Sono a disposizione stream di output e stream di input, basato
su byte oppure basato su caratteri.
Esistono numerose varianti degli stream per la scrittura e
lettura, occorre scegliere la più adatta al tipo di dati che si sta
trattando.
Nei Character Stream le due classi astratte principali sono
Reader e Writer (per leggere e scrivere).
È possibile legare uno stream ad un file su disco mediante
l'uso della classe per lo stream di tipo File.
RandomAccessFile è la classe più conviente per gestire i File,
ma perdendo la possibilità di gestione a livello di caratteri.
Linguaggio Java
81/92
Metodi Standard
Reader:
read()
legge un carattere
read(char[])
legge un buffer di caratteri
Writer:
write(int c)
scrive un carattere
write(String str)
scrive una stringa
flush()
forza lo stream in uscita in scrittura
Linguaggio Java
82/92
Uso di Stream File (Byte o riented)
import java.lang.*;
import java.io.*;
public class FilIOApp {
public static void main(String args[])
throws IOException {
FileOutputStream outStream = new
FileOutputStream("Test.txt");
String s = "This is a test!";
for(int i=0;i<s.length();++i)
outStream.write(s.charAt(i));
outStream.close()
// Ora riapre il file per la lettura
FileInputStream inStream = new
FileInputStream("Test.txt");
int inBytes = inStream.available();
byte inBuf[] = new byte[inBytes];
int bytesRead= inStream.read(inBuf,0,inBytes);
System.out.println(new String(inBuf));
inStream.close();
File f=new File("Test.txt");
f.delete(); } }
Linguaggio Java
83/92
Rando mAccessFile
private void fileIssue(String fileName) {
try {
RandomAccessFile file = new
RandomAccessFile(fileName, "r");
long filePointer = 0;
long length = file.length();
while (filePointer < length)
{
String s = file.readLine()+"\n\r";
out.writeChars(s);
filePointer = file.getFilePointer();
}
} catch (Exception e) {
System.err.println(e.toString());
}
}
Linguaggio Java
84/92
Networking
La libreria java.net.* consente di creare dei Socket TCP ed
UDP per la trasmissione di datagrammi e la ricezione di essi.
Le classi principali sono:
Socket: crea un Socket TCP client
ServerSocket: crea un Socket TCP server in ascolto
InetAddress: gestisce gli indirizzi IP
DatagramPacket: consente la gestione di datagrammi per
l'invio/ricezione di pacchetti UDP.
Linguaggio Java
85/92
C reazione di un So cket di Trasmissione
// Attacca il socket
try {
s = new Socket(host, port);
String myAddressAndPort =
s.getInetAddress() + ":"+ s.getPort();
System.err.println("Connected to server
at " + myAddressAndPort);
}
catch (IOException e) {
System.err.println("Couldn't make
socket: "+ e);
}
Linguaggio Java
86/92
Scrittura su So cket Client
try {
sout = new
PrintWriter(socket.getOutputStream());
System.err.println("Typist thread
opened output stream to server");
}
System.err.println ("Typist thread
can't open output stream to server");
parent.errorString1 = "Cannot
initialize connection.";
parent.errorString2 = "Threads
stopped.";
return;
}
Linguaggio Java
87/92
Scrittura su So cket C lient (2 )
//Creo la stringa contenente l'IP e la
porta locale per il callback
byte[] addr =
socket.getLocalAddress().getAddress();
IpPort =
(addr[0]&0xff)+"."+(addr[1]&0xff)+"."+(addr[2]
&0xff)+"."+(addr[3]&0xff);
IpPort = IpPort+ ":" +
socket.getLocalPort() + " ";
parent.moto.advise(this, IpPort);
}
//Spedisce un evento
public void sendEvent(String lineEvent) {
lineEvent = lineEvent.trim() + "\n";
sout.print(lineEvent);
sout.flush();
}
Linguaggio Java
88/92
Uso di Socket Server
// Apre il socket di ascolto TCP
try {
listen_socket = new ServerSocket(port); }
fail(e, "Exception creating server socket");}
// Fai partire il thread di ascolto sul socket
TCP
this.start(); }
public void run() {
try {
while(true) {
Socket client_socket =listen_socket.accept();
Connection c = new Connection(client_socket,
this); }
} catch (IOException e) {
fail(e, "Exception while listening for
connections"); }
}
Linguaggio Java
89/92
Apertura Stream per Socket
try {
in = new
DataInputStream(client.getInputStream());
out = new
DataOutputStream(client.getOutputStream());
}
try {
client.close();
log("Successfully closed
client socket");
}
catch (IOException e2) {
}
logException(e, "Exception while
getting socket streams");
return;
}
Linguaggio Java
90/92
Lettura e Stampa su Stream dei So cket
// legge un carattere e ne fa l'echo
// sul terminale remoto
line="";
charIn= 0;
sb = new StringBuffer("");
while (charIn != 10) {
charIn= in.read();
out.writeChar(charIn);
sb.append((char) charIn);
}
out.flush();
line = sb.toString();
line = line.substring(0,line.length()-2);
Linguaggio Java
91/92
Package Standard
Java è dotato di un numero elevato ed in continua crescita di
package standard e di API di supporto.
Tra le più importanti:
java.awt
consente di costruire interfacce grafiche/visuali (Bottoni,
finestre, ecc.)
java.swing
Miglioramenti alla GUI con elementi di interfaccia avanzati
JDBC
Strato di accesso via SQL a qualsiasi DBMS
Linguaggio Java
92/92

Linguaggio Java - UniCam - Computer Science Division

Transcript

Documenti analoghi

Tecniche di Programmazione

Economia: Carlyle G. acquisisce quota maggioranza

Economia: Carlyle G. acquisisce quota maggioranza in Light Force

Java lezione 8: Input e Output

Testo degli esercizi di laboratorio relativi agli appelli di Settembre e

Contenuti prescrittivi

Summary II ed - Master Homeland Security

Programma PDF

Le funivie panoramiche del Pan di Zucchero