Java - SIMA

UNIVERSITA’ DI FIRENZE
Facoltà di Ingegneria
Ingegneria del Software
Introduzione a Java
Premessa e obiettivi di questa parte
•
•
•
•
La tecnologia Java e’ stata sviluppata da un team della Sun Microsystem a partire
dal 1991. Il rilascio ufficiale e l’integrazione in internet di Java e’ avvenuto nel 1995.
Java è molto di più di un linguaggio di programmazione
E’ un ambiente, non solo nel senso di un insieme di tools per scrivere e debuggare i
programmi, ma nel senso più ampio di un insieme di librerie standardizzate che
coprono ogni aspetto del linguaggio, del suo impiego, etc..
Quest’insieme di librerie è estremamente ampio e per usare bene Java occorre
avere una certa dimestichezza con le sue librerie
•
Scopo di queste lezioni è far superare i problemi che si presentano al neofita
•
Il Software Development Kit di Java è distribuito gratuitamente, lo potete scaricare da
http://java.sun.com/j2se/1.4.2/download.html o http://java.sun.com/j2se/1.5.0/download.jsp
•
Si rende necessario un esame autonomo della documentazione fornita dalla Sun:
– La documentazione associata al JDK
– Il tutorial
Java (bucci/sassoli)
2
Parte 1
•
•
Cosa è Java?
Quali sono le sue caratteristiche generali?
Java (bucci/sassoli)
3
Java
–Semplice e orientato agli oggetti
–Interpretato
–Architetturalmente neutro e portabile
–Robusto
–Distribuito
–Sicuro
–Ad elevate prestazioni (?)
–Concorrente (multithread)
Indirizzi Utili:
•
In generale: http://java.sun.com/
•
Libro Eckel: http://www.BruceEckel.com
Java (bucci/sassoli)
4
SEMPLICE E OO
•
•
Sintassi simile a C e C++ (facile da imparare)
Elimina i costrutti più "pericolosi" di C e C++
–
–
–
–
–
•
•
aritmetica dei puntatori
(de)allocazione esplicita della memoria
strutture (struct)
definizione di tipi (typedef)
preprocessore (#define)
Aggiunge garbage collection automatica
Conserva la tecnologia OO di base di C++
– C++ dovendo mantenere la compatibilità col C può ancora essere usato per la
programmazione procedurale/funzionale
– Pure Java mantiene aspetti della programmazione procedurale, ma è impossibile
dimenticarsi che si è in un contesto OO (gli stessi programmi sono oggetti!)
Java (bucci/sassoli)
5
Interpretato
•
•
Il compilatore produce un codice di tipo intermedio per una “Java Virtual Machine”
(“byte-code”) ...
… che viene interpretato
codice
codice
sorgente
sorgente
Java (bucci/sassoli)
compilatore
compilatore
byte
bytecode
code
interprete
interprete
6
BYTECODE: ESEMPIO
void spin ( ) {
int i;
for (i = 0; i < 100; i++) {
;
}
}
0
iconst_0
1
2
5
8
9
11
14
Java (bucci/sassoli)
istore_1
goto 8
iinc 1 1
iload_1
bipush 100
if_icmplt 5
return
// push int constant 0
// store into local 1 (i=0)
// first time, don’t increment
// increment local i by 1 (i++)
// push local 1 (i)
// push int constant (100)
// compare, loop if < (I<100)
// return void when done
7
ARCHITETTURALMENTE NEUTRO
•
Il byte-code è indipendente dall’architettura hardware
(ANDF: Architecture Neutral Distribution Format)
•
Pertanto, un programma bytecode può essere eseguito su qualsiasi sistema su cui giri
un ambiente run-time Java
Java (bucci/sassoli)
8
Esempio
Sistema tradizionale
eseguibile
eseguibile
macchina
macchinaAA
compilatore
compilatore
macchina
macchinaAA
codice
codice
sorgente
sorgente
compilatore
compilatore
macchina
macchinaBB
eseguibile
eseguibile
macchina
macchinaBB
…….
Sistema ANDF
compilatore
compilatore
macchina
macchinaAA
codice
codice
sorgente
sorgente
compilatore
compilatore
macchina
macchinaBB
…….
Java (bucci/sassoli)
interprete
interprete
macchina
macchinaAA
byte
bytecode
code
interprete
interprete
macchina
macchinaBB
…….
9
Portabile
•
Il sistema Java (compilatore + interprete + librerie run-time) è facilmente portabile su
piattaforme diverse
codice
codice
sorgente
sorgente
compilatore
compilatore
byte
bytecode
code
interprete
interprete
libreria
libreria
•
•
•
S.O.
il compilatore Java è scritto in Java
l’ambiente run-time è scritto in ANSI C con interfacce
standard (POSIX) verso il sistema operativo
nessuna “implementation dependency”
Java (bucci/sassoli)
10
Robusto
•
•
Controlli estensivi a compile-time e a run-time, per rilevare gli errori quanto prima
possibile (es.: type checking)
Per questo, le caratteristiche insicure di C e C++ sono rimosse:
– Nessuna gestione esplicita dei puntatori (no aritmetica dei puntatori, no malloc e free
esplicite, …)
– Gestione della memoria con garbage collection
– Array e stringhe “veri”
•
Verifica del byte-code a load-time
Java (bucci/sassoli)
11
Distribuito
•
•
•
Pensato per essere eseguito in rete
L’ambiente run-time incorpora funzioni di rete
(sia di basso livello: TCP/IP, che di alto livello: HTTP, …)
La rete è facilmente accessibile (come i file locali)
Approccio tradizionale
DATI
PROGRAMMI
RETE
Network computing
RETE
Java (bucci/sassoli)
PROGRAMMI E DATI
load
and run
12
Sicuro
•
L’ambiente di esecuzione si protegge da bytecode potenzialmente “ostile”
•
Esempi:
– il bytecode viene verificato prima dell’interpretazione (“theorem prover”), in modo da essere
certi di alcune sue caratteristiche
– gli indirizzamenti alla memoria nel bytecode sono risolti sotto il controllo dell’interprete
Java (bucci/sassoli)
13
COMPILE-LOAD-RUN
Loader
Loader
delle
delleclassi
classi
Sorgente
Sorgente
Java
Java
Verifica
Verificadel
del
byte-code
byte-code
Interprete
Interprete
Rete
Compilatore
Compilatore
Byte-code
Byte-code
Java
Java
Ambiente
Ambiente
run-time
run-time
hardware
hardware
Java (bucci/sassoli)
14
Prestazioni
•
La verifica del bytecode permette di saltare molti controlli a run-time: l’interprete è
pertanto efficiente
•
Per maggiore efficienza, possibilità compilazione on-the-fly del bytecode in codice
macchina
•
(Molto) Inferiore al C/C++
Java (bucci/sassoli)
15
Compilazione on the fly
Loader
Loader
delle
delleclassi
classi
Sorgente
Sorgente
Java
Java
Verifica
Verificadel
del
byte-code
byte-code
Interprete
Interprete
Rete
Generatore
Generatore
di
dicodice
codice
Compilatore
Compilatore
Byte-code
Byte-code
Java
Java
Ambiente
Ambiente
run-time
run-time
hardware
hardware
Java (bucci/sassoli)
16
Concorrente
•
Multithreading parte integrante del linguaggio:
– Applicazioni interattive più facili a scriversi
– Migliore "reattività" (anche se non real-time)
OS
OS
Task
Task
11
Task
Task
22
Memoria
condivisa
Monitor
Monitor
(interprete
(interpreteJava)
Java)
Thread
Thread
11
Thread
Thread
22
Thread
Thread
33
Memoria
condivisa
Memoria locale
Memoria locale
Java (bucci/sassoli)
17
Ben supportato
La Standard Library Java contiene una ricca collezione di classi e di metodi
preconfezionati:
–
–
–
–
–
–
–
Language support
Utilities
Input/output
Networking
Abstract Window Toolkit (AWT)
Swing
…
Java (bucci/sassoli)
18
Java RoadMap
•
•
•
JDK 1.0
JDK 1.0.
JDK 1.1
Usata dai browser della vecchia generazione
Aggiunge molte estensioni:
• Estensioni al linguaggio
• NMI, RMI, JDBC, Beans
•
JDK 1.1.7
•
Nella terminologia Java si parla di Java 2 : il termine è stato introdotto a partire dal
rilascio del JDK 1.2
•
JDK 1.2
–
Aggiunge soprattutto JFC (Swing)
• Swing
• Java 2D
A un certo punto hanno aggiunto un 2
•
•
J2DK 1.4.2
J2DK 5.0 Ultima versione
•
In realtà si dovrebbe usare la dizione SDK, ma tutti continuano a usare la dizione JDK
Java (bucci/sassoli)
19
Parte 2
•
Per Iniziare…
Java (bucci/sassoli)
20
Per iniziare….
• Procuriamoci (almeno) il Java development kit
e la Java api documentation
• http://java.sun.com/
JDK – Java Development Kit
JRE – Java Runtime Environment
JVM – Java Virtual Machine
AWT – Abstract Windowing Toolkit
JFC – Java Foundation Classes
RMI – Remote Method Invocation
JDBC – Java Data Base Connectivity
BDK – Beans Development Kit
ecc
Java (bucci/sassoli)
21
Per iniziare…
• Procuriamoci un tool per lo sviluppo
• Consigliati e free!
– JCreator: leggero e facilissimo (ottimo per iniziare)
http://www.jcreator.com/
– Eclipse: più pesante, ma completo
(vero riferimento per un non-neofita)
http://www.eclipse.org/
Java (bucci/sassoli)
22
Un programma di esempio
•
Il programma HelloWorld
//: HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“Hello World!”);
}
}
•
Compilazione di HelloWorld
javac HelloWorld.java
•
Esecuzione di HelloWorld
java HelloWorld
Java (bucci/sassoli)
//L’estensione è obbligatoria
//produce HelloWorld.class
//byte-code
Byte Code Java
Macchina Virtuale
(Interprete)
Sistema Operativo
Hardware
23
Un applet di esempio
•
L’applet HWApplet
//: HWApplet.java
import java.applet.Applet;
import java.awt.Graphics;
public class HWApplet extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
•
Compilazione di HWApplet
javac HWApplet.java
Java (bucci/sassoli)
24
..Un applet di esempio
•
Testo HTML per usare l’applet
<HTML>
<HEAD>
<TITLE> A Simple Program </TITLE>
</HEAD>
<BODY>
Here is the output of my program:
<APPLET CODE="HWApplet.class" WIDTH=150 HEIGHT=25>
</APPLET>
</BODY>
</HTML>
•
Uso del programma appletviewer
appletviewer HWApplet.html
•
Alternativamente si può cliccare su HWApplet.html, oppure fare “drag & drop”
Java (bucci/sassoli)
25
Un programma Swing
// HWSwing
import javax.swing.*;
public class HWSwing {
public static void main(String[] args) {
JFrame frame = new JFrame("HelloWorldSwing");
final JLabel label = new JLabel("Hello World");
frame.getContentPane().add(label);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
}
}
Java (bucci/sassoli)
26
Parte 3
•
Linguaggio Java
Java (bucci/sassoli)
27
Tipi di dati primitivi di Java
•
Interi
byte
short
int
long
Wrapper
8-bit two's complement
16-bit two's complement
32-bit two's complement
64-bit two's complement
Byte
Short
Integer
Long
32-bit IEEE 754
64-bit IEEE 754
Float
Double
char
boolean
16-bit Unicode character
true or false
Character
Boolean
void
--
void
•
Numeri reali
float
double
•
Altri tipi
Java (bucci/sassoli)
28
Parole Chiave
Le seguenti keywords non possono essere usate come identificatori:
abstract
double
int
super
boolean
else
interface
switch
break
extends
long
synchronized
byte
final
native
this
case
finally
new
throw
catch
float
package
throws
char
for
private
transient
class
(goto)
protected
try
(const)
if
public
void
continue
implements
return
volatile
default
import
short
while
do
instanceof
static
Note: - const e goto sono riservate, ma non usate
- anche i letterali null, true, false sono riservati
Java (bucci/sassoli)
29
Dati Primitivi
•
Non richiedono l’uso di new per creare un’istanza di quel tipo
Sarebbe stato troppo inefficiente dover usare new anche per le semplici
variabili:
– Con il new gli oggetti vengono messi nell’ heap.
– Con la normale dichiarazione vengono messi nello stack.
•
La sintassi è quella del C/C++
int
int
double
boolean
char
Java (bucci/sassoli)
n, m;
Kappa=4;
var=32.67;
yes;
c;
//
//
//
//
//
due variabili intere
una variabile intera inizializzata
variabile reale inizializzata
variabile booleana
c è di tipo carattere
30
Statement di controllo
•
•
•
•
Decisione
Ciclo
Eccezione
Vari
if-else, switch-case
for, while, do-while
try-catch-finally, throw
break, continue, label: , return
int testscore;
char grade;
if (testscore >= 90)
grade = 'A';
} else if (testscore
grade = 'B';
} else if (testscore
grade = 'C';
} else if (testscore
grade = 'D';
} else {
grade = 'F';
}
Java (bucci/sassoli)
{
>= 80) {
>= 70) {
>= 60) {
int month;
. . .
switch (month) {
case 1:
System.out.println("January");
break;
case 2:
System.out.println("February");
break;
case 3: . . . .
. . . . .
case 12:
System.out.println("December");
break;
default: System.out.println("Hey,
that's not a valid month!");
break;
}
31
Statement di controllo
for (initialization; termination; increment)
statements
// a è un array
. .
int i;
int length = a.length;
for (i = 0; i < length; i++) {
. . .
// uso dell’elemento i-mo di a
. . .
}
do {statements
} while (booleanExpression);
int c;
Reader in;
. . .
do {
c = in.read();
. . .
} while (c != -1);
Java (bucci/sassoli)
32
Dati non primitivi
•
•
Sono gli oggetti e gli array.
Vengono detti reference types perché essi sono manipolati attraverso
riferimenti, ovvero attraverso il loro indirizzo (per esempio passandoli ad un
metodo)
– Al contrario i dati primitivi vengono sempre passati per valore
Le stringhe sono un caso a parte:
•
•
Non sono dati primitivi, ma istanze della classe String
Si trattano come dati primitivi
– si possono istanziare senza il new
– i caratteri della stringa possono apparire tra virgolette e il compilatore li trasforma in
stringhe
Java (bucci/sassoli)
33
Gli oggetti si manipolano attraverso riferimenti
•
La dichiarazione
String s;
non crea un oggetto, ma un handle, cioè un “riferimento” (un puntatore) di nome s ad un
oggetto di tipo String.
•
L’oggetto ancora non esiste. Per mettere in esistenza un oggetto occorre usare new.
Ecco alcune possibilità:
s = new String(); //crea una oggetto stringa e pone
// in s è il riferimento (handle)
s = new String(“abcd”); //oggetto creato e inizializzato
String s = new String(“abcd”); //dich. e inizializzazione
Le stringhe sono un caso speciale e possono essere inizializzate anche senza new:
String s = “abcd”;
Java (bucci/sassoli)
34
Riferimenti
Pippo
String s = “Pippo”;
s
Pippo
se viene eseguito lo stat:
s = “Pluto”;
se viene eseguito lo stat:
s = “Paperino”;
s
Pluto
Pippo
s
Pluto
Paperino
I riferimenti precedenti in s sono persi (“vittime” del garbage collector)
Java (bucci/sassoli)
35
La classe String
• In Java le stringhe sono first-class objects
mentre in C++ le stringhe sono array di caratteri
terminati da ‘\0’
• Al contrario del C++, in Java le stringhe hanno
un comportamento affidabile e consistente
String e = “”; // stringa vuota
String s = “Hello”;
String t = new String(“Hello”);
String u = new String(s);
char[] d = {‘a’, ‘b’, ‘c’};
String v = new String(d);
Java (bucci/sassoli)
36
Operazioni sulle stringhe
• Concatenazione (+)
String v = “Via ”; // stringa vuota
String n = “Roma ”;
String i = v + n + 2;
• Sottostringhe
String s = “Hello ”; // stringa vuota
String t = s.substring(0, 4); // Hell
• Editing
int n = s.length(); // 5
char c = s.charAt(4); // ‘o’
String z = s.substring(0, 4) + ‘!’; // Hell!
Java (bucci/sassoli)
37
Operazioni sulle stringhe
• Confronto tra stringhe
String s = “pippo”;
String t = “pluto”;
boolean b1 = s.equals(t); //false
boolean b2 = “pippo”.equals(s); // true
String u = “Pippo”;
boolean b3 = s.equalsIgnoreCase(u);
//true
NON USARE == per confrontare due stringhe
Java (bucci/sassoli)
38
La classe String
System.out.println("Salve");
Il riferimento a un’oggetto String (costante) si ottiene mettendo la stringa tra virgolette
“Salve”
Riferimento
istanza di String
(Salve)
Oggetto
“Salve”.toUpperCase()
// toUpperCase() è un metodo della classe String
toUpperCase()
“Salve”
Riferimento
istanza di String
(Salve)
Messaggio
Oggetto
Java (bucci/sassoli)
39
La classe String
public class FaiMaiuscole {
public static void main (String argv[]) {
System.out.println("Salve: parliamo di stringhe");
System.out.println("una stringa di minuscole".toUpperCase());
} // main
} //FAiMaiuscole
Riferimento
“una stringa. ..le”.toUpperCase()
Riferimento
Istanza di String
(una . . le)
Oggetto ricevente
Istanza di String
(UNA .. LE)
Oggetto appena creato
“una stringa di minuscole".toUpperCase() non modifica l’oggetto “una stringa
di minuscole”, ma crea il nuovo oggetto “UNA STRINGA DI MINUSCOLE” e
restituisce il puntatore ad esso
Java (bucci/sassoli)
40
La classe String
•
Una volta creati gli oggetti String non subiscono mai variazioni
•
•
Possono essere concatenati ad altri oggetti della stessa classe, oppure si può
ricercare una sotto stringa, etc, ma in questi casi vengono sempre creati nuovi oggetti
di classe String
gli oggetti di classe String sono immutabili
•
Esempio
S = nome.concat(secnome).concat(cognome);
•
il messaggio concat(secnome) è inviato a nome. L’oggetto nome restituisce il
riferimento al nuovo oggetto (per esempio Carlo Azelio )
•
il messaggio concat(cognome) inviato al nuovo oggetto restituisce il riferimento ad un
nuovo oggetto (per esempio Carlo Azelio Ciampi ) che è ancora una stringa
Java (bucci/sassoli)
41
Scope (dei dati primitivi)
•
Non esattamente uguale al C
{
int x = 10;
// x è visibile qui
{
int q = 11;
// x e q visibili
}
// solo x visibile; q non è visibile
}
{
int x = 10;
{
int x = 11;
}
//Errore: non è consentito nascondere le variabili
// di uno scope più grande
}
Java (bucci/sassoli)
42
Scope degli oggetti
•
Gli oggetti restano anche se viene chiuso lo scope in cui vengono istanziati con il
new
{
String s = new String(“La vispa Teresa”)
}
// fine dello scope di s
•
•
Fuori dallo scope s sparisce, ma l’oggetto stringa esiste ancora nell’heap
Non c’è modo di recuperarlo, in quanto si è perso il riferimento
•
Java possiede un garbage collector. All’occorrenza vengono individuati ed
eliminati tutti gli oggetti che non sono più riferiti e la relativa memoria viene resa
disponibile.
E’ una differenza fondamentale rispetto al C++
•
Java (bucci/sassoli)
43
Classi e oggetti
•
La classe determina come si comportano gli oggetti che ad essa appartengono.
class UnTipo { /* corpo della classe */ }
Una classe ha
– Attributi
– Metodi
(data members, fields)
(function members)
class Ora {
//attributi
int ore; int minuti; int secondi;
//Metodi
public void setOra(int ore, int minuti, int secondi) ;
public final int getOre() ;
public final int getMinuti() ;
public final int getSecondi() ;
public void tick() ;
}
Java (bucci/sassoli)
44
Classi e oggetti
•
Un oggetto del classe UnTipo si crea così
UnTipo x = new UnTipo();
Ora orario = new Ora();
•
•
Gli attributi che sono dati primitivi hanno un valore predefinito (default) se non
vengono inizializzati (false per i boolean; null per i char; 0 per tutti gli altri). Lo scopo
è quello di evitare una usuale fonte di errore
Anche i riferimenti hanno il valore predefinito null
Java (bucci/sassoli)
45
Metodi
•
Dichiarazione:
returnType methodName (/* argument list */)
/* corpo del metodo *
}
•
{
I metodi possono essere chiamati solo come membri di un oggetto (con eccezione per
quelli dichirati static, esempio:
int x =
obj.method() //chiamata di method di obj
int minuti = orario.GetMinuti();
Si dice che all’oggetto obj viene inviato il messaggio method()
•
Gli argomenti di un metodo sono variabili (tipo primitivo) o oggetti; le variabili vengono
passate per valore, per gli oggetti viene passato il riferimento
Java (bucci/sassoli)
46
Invio messaggi/invocazione metodi
•
Forma generale:
<Riferimento>.<messaggio>
•
Esempio:
System.out.println(“un testo”)
Riferimento al ricevente
Java (bucci/sassoli)
Messaggio
Metodo
Comportamento
47
Static
•
Quando si definisce una classe si definisce un modello di comportamento. Fino a che
non si istanzia un oggetto non si ha nulla di quella classe
Può capitare la necessità di aver un solo esemplare di dato o un solo esemplare di metodo,
indipendentemente da quanti oggetti sono stati creati. Ciò si ottiene con la parola chiave
static
esempio attributo statico:
alieni attaccano giocatore solo se sono in numero maggiore di 5, la classe
alieno avrà un contatore statico, incrementato nel costruttore dell’alieno
•
Un membro statico non è associato ad alcun oggetto, ma resta associato alla classe
Si parla di class data (o class field, class variables) e di class method
Java (bucci/sassoli)
48
Attributo statico
•
•
Un attributo statico
class StaticData {
static int x = 10;
}
//chiaramente non va nel costruttore
Due istanze di StaticData
StaticData s1 = new StaticData();
StaticData s2 = new StaticData();
s1.x e s2.x valgono ambedue 10 (sono lo stesso elemento di memoria)
•
Il modo migliore per fare riferimento a un attributo statico è nominare la classe:
StaticData.x++;
A questo punto s1.x e s2.x valgono 11
Java (bucci/sassoli)
49
Metodo statico
•
•
•
A un metodo statico si può fare riferimento sia nominando un’istanza (un oggetto) che
la classe in cui è definito
Un metodo statico
class StaticMet {
static void incr() {StaticData.x++;}
}
Uso del metodo statico attraverso un oggetto:
StaticMet sm = new StaticMet();
sm.incr();
•
Uso del metodo statico attraverso la classe:
StaticMet.incr();
•
L’uso di metodi statici permette la loro chiamata senza che sia stata istanziata la
classe. Diventa essenziale per il metodo main() (l’entrata di qualunque
applicazione): l’istanziazione della classe che contiene il main() non comporta un
main() per ciascuna istanza
Java (bucci/sassoli)
50
Ritorniamo al programma di esempio
•
Il programma HelloWorld
//: HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println(“Hello World!”);
}
}
•
•
Compilazione di HelloWorld
javac HelloWorld.java
//L’estensione è obbligatoria
//produce HelloWorld.class
Esecuzione di HelloWorld
java HelloWorld
Java (bucci/sassoli)
51
Osservazioni sul programma
•
•
•
Il file contenente il programma è un’unità di compilazione.
Ogni unità di compilazione deve avere l’estensione .java
Ogni unità di compilazione deve contenere una classe dichiarata public con lo stesso
nome del file (public class HelloWorld)
•
In un’unità di compilazione ci deve essere una sola classe public (le altre classi non
sono visibili dall’esterno (del package); in pratica esse svolgono funzione di supporto per
la classe pubblica)
La compilazione produce tanti file quante sono le classi dichiarate al suo interno, con
estensione .class
•
•
La classe pubblica deve contenere il metodo pubblico main()
public static void main(String[] args) {
Il metodo è statico (non si deve creare un oggetto HelloWorld per far andare l’applicazione)
Il metodo ha come argomento un oggetto che è un vettore di stringhe (l’argomento non
viene usato nel programma HelloWorld)
Java (bucci/sassoli)
52
.. Osservazioni sul programma
• System è una classe della libreria di classi java.lang, questa libreria è
automaticamente inclusa in ogni unità di compilazione e le classi in essa contenute
rese disponibili
Vedere la documentazione Sun [ C:\Java\docs\api\index.html ] e selezionare il package java.lang
•
Si scopre che System ha un certo numero di field (attributi) e che uno di questi è il
campo out
• out è uno static PrintStream. Trattandosi di un attributo statico non c’è niente
da creare (è un attributo della classe System), si può usare direttamente.
• Quel che si può fare con out è determinato dal suo tipo: PrintStream
• La classe PrintStream (occorre navigare nella documentazione Sun) presenta diversi metodi,
tra cui println
• println accetta diversi tipi di argomenti, in particolare accetta le stringhe
Java (bucci/sassoli)
53
Nella documentazione
Java (bucci/sassoli)
54
...
Java (bucci/sassoli)
55
Java (bucci/sassoli)
56
Java (bucci/sassoli)
57
Esempio: argomenti al main
public class Argomenti {
public static void main(String args[]) {
for(int i = 0; i < args.length; i++)
System.out.println(args[i]);
}
}
•
Stampa gli argomenti:
>java Argomenti un due tre
>un
>due
>tre
Java (bucci/sassoli)
58
Esempio: lettura proprietà del sistema
// Property.java
// Dal libro di B. Eckel “Thinking in Java”
import java.util.*;
public class Property {
public static void main(String[] args) {
System.out.println(new Date());
Properties p = System.getProperties();
p.list(System.out);
System.out.println("--- Memory Usage:");
Runtime rt = Runtime.getRuntime();
System.out.println("Total Memory = "
+ rt.totalMemory()
+ " Free Memory = "
+ rt.freeMemory());
}
}
Java (bucci/sassoli)
59
Osservazioni
• import java.util.*; importa le classi nel package util (quelle del package
java.lang sono comunque importate)
• System.out.println(new Date()); crea un oggetto Date e lo passa come
argomento a println. Quando lo statement è finito l’oggetto Date non serve più e,
non essendoci riferimento ad esso, il garbage collector lo può togliere di mezzo
• Date appartiene al package java.util.
import java.util.Date
Si poteva scrivere
• System presenta il metodo statico getProperties() che restituisce un oggetto di
tipo Properties (le proprietà del sistema). Essendo il metodo statico, non c’è
bisogno di istanziare niente
•
Navigando si trova che Properties ha il metodo list() che lista le proprietà
sull’oggetto PrintStream passato come argomento
Java (bucci/sassoli)
60
Osservazioni
• Analogo discorso per la classe Runtime e il relativo metodo statico get.Runtime()
• totalMemory e freeMemory sono metodi non statici di Runtime
•
Notare l’uso dell’operatore + per le stringhe (operator overloading: è un’eccezione,
diversamente dal C++ Java non consente l’overloading degli operatori)
Java (bucci/sassoli)
61
Cosa si legge navigando in DOCS
•
Al package java.lang per la classe System si trova
static PrintStream out
The "standard" output stream
•
Andando a PrintStream si trovano una gran quantità di println, tra cui
void print(String s)
Print a string.
void println(Object x)
Print an Object and then terminate the line.
•
Per la classe Runtime si trova
getRuntime
public static Runtime getRuntime()
Returns the runtime object associated with the current Java application. Most of the methods
of class Runtime are instance methods and must be invoked with respect to the current
runtime object.
Returns:
the Runtime object associated with the current Java application.
Java (bucci/sassoli)
62
Documentazione
•
•
Formato standard
Usa i commenti
– // commento stile C++
– /* commento stile C */
– /** commento javadoc */
•
javadoc crea la documentazione in HTML (considera solo i commenti per membri public e
private)
/** A class comment */
public class Aclass {
/** A variable comment */
public int x;
/** A method comment */
public void f() {}
}
•
Altra possibilità è usare @
• @see classname
Crea un iper link
• @see fully-qualified-classname#method-name
Crea un iper link
• e altri modi
Java (bucci/sassoli)
63
Esempio documentato
// PropertyCommentato.java
/** Questo esempio è tratto dal libro di B. Eckel “Thinking in Java”. Il
libro è scaricabile da Internet all’indirizzo
http://www.BruceEckel.com */
import java.util.*;
/** presenta sullo standard output una lunga lista di proprità del sistema
Java in uso, più dati relativi alla memoria */
public class PropertyCommentato {
/** Embedded HTML
* <ol>
* <li> Uno
* <li> Due
* </ol> */
public static void main(String[] args) {
System.out.println(new Date());
Properties p = System.getProperties();
p.list(System.out);
System.out.println("--- Memory Usage:");
Runtime rt = Runtime.getRuntime();
System.out.println("Total Memory = "
+ rt.totalMemory()
+ " Free Memory = "
+ rt.freeMemory());
}
}
Java (bucci/sassoli)
Provare a sottoporlo a
javadoc ed esaminare il
risultato
64
Costruttori e altro
•
Esempio di classe
public class Cerchio{
public double x, y;
public double r;
//coord del centro
// raggio
//metodi che valutano circonferenza e area
public double circonf() { return 2 * 3.14 * r; }
public double area(){ return 3.14 * r * r;}
}
Java (bucci/sassoli)
65
... Costruttori e altro
•
Uso di Cerchio
double A;
Cerchio c = new Cerchio();
c.x = 2.0;
//inizializzazione (ascissa del centro)
c.y = 4.0;
c.r = 1.0;
A = c.area();
•
Quando si è scritto:
Cerchio c = new Cerchio();
Si è usato il costruttore implicito della classe.
•
•
•
Un costruttore e’ un metodo che ha sempre il nome della classe
E' possibile dichiarare costruttori in modo esplicito
E' possibile dichiarare più di un costruttore per una stessa classe
Java (bucci/sassoli)
66
... Costruttori e altro
La componente r
dell’oggetto
public class Cerchio{
public double x, y;
//coord del centro
public double r;
// raggio
public Cerchio(double x, double y, double r){
this.x = x; this.y = y; this.r =r;} //costruttore
public double circonf() { return 2 * 3.14 * r; }
public double area() { return 3.14 * r * r ;}
Il parametro r
}
•
Questa volta il costruttore inizializza il cerchio
Cerchio c = new Cerchio(1.3, 17.0, 10.0);
•
E' il cerchio che ha coordinate (1.3, 17.0) e raggio 10.0
E’ un overloading dei metodi (in questo caso costruttori)
Java (bucci/sassoli)
67
Overloading dei metodi
•
Con lo stesso nome si denotano metodi che fanno cose diverse (possibilmente non
del tutto scorrelate!)
void metodo ()
void metodo (int a)
void metodo (int a, int b)
•
Nel caso dei costruttori equivale a dare la possibilità di costruire gli oggetti della
stessa classe in modi diversi (vedi esempio precedente)
•
La distinzione avviene sulla base della lista degli argomenti. Ogni costruttore (o
metodo, nel caso generale) deve avere una lista di argomenti differente dagli altri.
void metodo (int i, float f) è diverso da
void metodo (float f, int i)
Java (bucci/sassoli)
68
Overloading dei metodi
//: Overloading.java
import java.util.*;
class Tree {
int height;
Tree() {
prt("Planting a seedling");
height = 0; }
Tree(int i) {
prt("Creating new Tree that is ”
+ i + " feet tall");
height = i;}
void info() {
prt("Tree is " + height
+ " feet tall");}
void info(String s) {
prt(s + ": Tree is "
+ height + " feet tall");
}
static void prt(String s) {
System.out.println(s); }
}
// Segue a destra
Java (bucci/sassoli)
// segue da sinistra
public class Overloading {
public static void main(String[]
args) {
for(int i = 0; i < 5; i++) {
Tree t = new Tree(i);
t.info();
t.info("overloaded method");
}
// Overloaded constructor:
new Tree();
}
}
69
Java (bucci/sassoli)
70
Il metodo equals
public class Test {
public static void main(String a[]) {
new Test();
}
Test() {
P p1=new P();
p1.x=1; p1.y=2;
P p2=new P();
p2.x=1; p2.y=2;
// come testare l'uguaglianza di p1 e p2?
}
}
Java (bucci/sassoli)
71
Il metodo equals e ==
public class Test {
public static void main(String[] a)}new Test();}
Test() {
P p1=new P();
p1.x=1; P1.y=2;
P p2=new P();
p2.x=1; p2.y=2;
System.out.println(p1 == p2); // stampa “false”
System.out.println(p1.equals(p2)); // stampa “true”
}
}
Java (bucci/sassoli)
72
Il metodo equals
• The equals method for class Object implements the most discriminating possible
equivalence relation on objects; that is, for any reference values x and y, this method
returns true if and only if x and y refer to the same object (x==y has
the value true).
Chiaramente se ne può fare un override
Java (bucci/sassoli)
73
Costanti
•
•
•
Si usa la parola final. Due aspetti:
– una costante definita al tempo di compilazione
– una costante definita al tempo di esecuzione che non deve essere più modificata
Il primo caso è l’equivalente del #define del C.
La costante PI del package matematico (java.lang.Math.PI):
public class Math{ ….
public static final double PI = 3.14159;
….}
Nel secondo caso la costante deve essere inizializzata a run time. Può essere usata
per un riferimento, nel qual caso punta sempre allo stesso oggetto (che, ovviamente,
può essere modificato)
Java (bucci/sassoli)
74
Costanti
•
La parola final può esser usata anche per gli argomenti dei metodi, per i metodi e per
le classi
– Se l’argomento è un riferimento ad un oggetto, dichiararlo final lo rende non
modificabile (al ritorno dal metodo l’argomento punta sempre allo stesso
oggetto, che tuttavia può essere modificato)
– Un metodo dichiarato final non può esser modificato nelle classi derivate
– Una classe final è una classe che non può essere usata per derivare altre
classi.
Java (bucci/sassoli)
75
.. Costanti
//: FinalData.java
class Value {
int i = 1; }
public class FinalData {
final int i1 = 9;
static final int I2 = 99;
public static final int I3 = 39;
}
Value v1 = new Value();
final Value v2 = new Value(); //v2 riferimento non modificabile
static final Value v3 = new Value();
//! final Value v4; // Error: deve essere inizializzata
public static void main(String[] args) {
FinalData fd1 = new FinalData();
//! fd1.i1++; // Error: non può cambiare
fd1.v2.i++;
// l’oggetto riferiro da v2 non è una costante
fd1.v1 = new Value(); // OK -- not final
// fd1.v2 = new Value(); // NO -- final
}
Java (bucci/sassoli)
76
Array
int[] a;//dichiarazione di un vettore di interi
•
Notare che non si danno le dimensioni; la dichiarazione costituisce definizione di un
riferimento (handle) ad un array. Occorre inizializzare. Ci sono due modi: usare new
oppure assegnare valori :
int[] a1 ={ 1, 2, 3, 4};
•
Se si dichiara int[] a2; e si scrive a1 = a2; si copia un riferimento non
l’array!
(Lo stesso concetto vale ovviamente se a1 e a2 fossero handle a generici oggetti)
a1
a2
Java (bucci/sassoli)
1,2,3,4
a1
1,2,3,4
a2
1,2,3,4
77
Array
public class Arrays {
public static void main(String[] args) {
int[] a1 = { 1, 2, 3, 4, 5 };
int[] a2;
a2 = a1;
for(int i = 0; i < a2.length; i++)
a2[i]++; //sto incrementando anche i dati di a1!!
for(int i = 0; i < a1.length; i++)
prt("a1[" + i + "] = " + a1[i]); }
static void prt(String s) {System.out.println(s);}
}
a1
a2
1,2,3,4,5
a1
2,3,4,5,6
1,2,3,4,5
a2
Java (bucci/sassoli)
a2
78
.. Array - Inizializzazione
•
Di dati primitivi
– int[] a = { 1, 2, 3 }
// aggregazione di oggetti
– Qui di seguito si crea un array la cui dimensione è fissata al tempo di esecuzione:
int[] a;
a = new int[iRand()]// iRand riporta un numero intero
•
Di Oggetti
– Ogg[] Q;// definisce un vettore di riferimenti a oggetti Ogg
– Q = new Ogg[20]
// alloca 20 riferimenti
ad oggetti di classe Ogg
Inizializzazione dei componenti l’array di oggetti
Q[0] = new Ogg();
Q[1] = new Ogg(/*parametri del costruttore*/); ….
Oppure
MyClass[]
Java (bucci/sassoli)
mc = { new MyClass(); new MyClass(“bella”);
new MyClass(“brutta”); ….}
79
Package
• Più classi o interfacce interrelate possono essere riunite in un package,
dotato di nome
• Conviene raccogliere le classi in un package
– per tenere assieme tutte le classi che provvedono funzionalità correlate
– per evitare collisione di nomi con altre classi: il package rappresenta uno
specifico spazio dei nomi (namespace)
– per definire regole di accesso alle classi nel package e tra di loro
Esempio:
MyPackage
classe o
interfaccia
c
b
a
d
Java (bucci/sassoli)
e
80
Alcuni Packages Standard
java.lang
classi base del linguaggio
java.io
classi di I/O
java.util
classi di utilità
java.net
java.applet
classi di supporto alle applicazioni di
rete (socket, URL, …)
classe Applet, …
java.awt
Abstract Windowing Toolkit
Java (bucci/sassoli)
(Object, Thread, Throwable, System, String,
Math, …)
(FileInputStream, FileOutputStream, )
(Date, Random, …)
81
Lo Statement package
• Specifica che le classi che seguono appartengono a un certo package
• Deve apparire (una sola volta) all’inizio di una unità di compilazione
Esempio:
a.java
package p;
class a {..
class b {...
class c {..
Java (bucci/sassoli)
le classi a,b,c appartengono
al package p
Se lo statement è omesso,
la classe appartiene al
package anonimo
82
Lo Statement package
•
Supponiamo di voler costruire il componente di libreria mypack e supponiamo che in
esso si voglia avere le classi MyC1 e MyC2:
package mypack; // primo statement (non di commento) dei file MyC1.java,
public class MyC1 {.. // MyC1 è accessibile dall’esterno del package
package mypack; // primo statement (non di commento) dei file MyC2.java,
public class MyC2{.. // MyC2 è accessibile dall’esterno del package
Java (bucci/sassoli)
83
Nomi di Package: Fully Qualified Name
• Il nome di un package può essere composto da più identificatori separati da “.”:
luigi.utilities.internet
• I progettisti hanno definito una regola per assegnare nomi univoci su tutta la rete
Internet (dovendo essere possibile il caricamento di una classe da qualunque
posizione della rete)
• La regola è quella di utilizzare l’indirizzo Internet
• Fully Qualified Name:
it.unifi.dsi.luigi.utilities.internet
nome di dominio
Cui corrisponde il percorso
it\unifi\dsi\luigi\utilities\internet
Java (bucci/sassoli)
84
Lo Statement import
• Per evitare di usare sempre nomi completi di classi, si può usare lo statement import
Esempio:
class MyClass {
java.util.Date today;
…
}
import java.util.Date;
class MyClass {
Date today;
...
}
Note:
• import java.util.* importa tutte le classi del package java.util
• java.lang.* è sempre importato implicitamente
Java (bucci/sassoli)
85
PACKAGE E DIRECTORY
• Molti ambienti Java mappano i nomi dei package sui pathname del file system
(compilatore e class loader)
Esempio:
aaa.bbb.ccc.MyClass
package
classe
aaa/bbb/ccc/MyClass
directories
file
pathname
Java (bucci/sassoli)
86
VISIBILITA’
Classi e interfacce
• sono visibili all’interno del package in cui sono dichiarate; sono visibili
all’esterno del package solo se dichiarate public
public class a { …
public interface b { …
Membri (campi e metodi)
• sono visibili quando:
– la loro classe è visibile e
– il loro modificatore li rende visibili
Java (bucci/sassoli)
87
più visibile
VISIBILITA’ DI CAMPI E METODI
Modificatore
Visibilità
private
solo nella classe in cui è definito
nessuno (default) solo nelle classi del package
protected
classi nel package e sottoclassi
(stesso package o altri package)
public
tutte le classi
NB: I membri di una interfaccia sono sempre pubblici
Java (bucci/sassoli)
88
ESEMPIO
package pac
class a {...
class b {
private int i;
private void m( ) {…}
int j;
visibile
void n( ) {…}
public int k;
public p( ){…}
protected int i;
protected void m( ){…}
class c {...
class
classddextends
extendsbb{...
{...
class e extends d {...
Java (bucci/sassoli)
89
PROGETTARE LA VISIBILITA’
Quando progettiamo una classe dobbiamo pensare a due tipi di utenti:
• quelli che utilizzeranno la classe per realizzare delle applicazioni
• quelli che estenderanno la classe per realizzare sottoclassi
• I primi useranno i membri public; i secondi anche i membri protected
• Le interfacce public e protected vanno progettate con cura
Java (bucci/sassoli)
90
Java Class Path
•
•
•
•
•
L’interprete java sa dove cercare le classi di sistema
Per default le classi di utente sono cercate nella cartella corrente
E’ possibile attraverso la variabile di environment ClassPath definire percorsi per
le classi di utente. L’interprete cerca prima nel ClassPath e poi nelle cartelle delle
classi di sistema
La variabile ClassPath deve specificare una cartella o file Zip o Jar contenenti le
classi
Esempio:
set classpath .;c:\documenti\corsi\IS\java;c:\documenti\corsi\MM\esempi.zip
Il classpath può essere specificato anche attraverso la linea di comando di javac
Java (bucci/sassoli)
91
Name Space: Nomi dei file java e delle directories
•
•
File java sorgente:
– statement package opzionale
– eventuali import
– una o più definizioni di classi (o di interfacce)
Ogni classe e ogni interfaccia è compilata (in bytecode ) come file a se’ stante, detto
class file. I class file hanno lo stesso nome della classe e l’estensione .class
Java (bucci/sassoli)
92
Name Space: Nomi dei file java e delle directories
•
I nomi dei package sono di norma composti di più parti separate da punti. Esempio:
package:
lezioni.grafica
class file:
cubo
metodo:
volume()
il fully qualified name del metodo sarebbe lezioni.grafica.cubo.volume()
•
I class file vengono memorizzati in una cartella il cui percorso (relativo al classpath)
ha la stessa struttura del fully qualified name. Esempio:
Il path della classe cubo sarebbe : lezioni/grafica/cubo.class
Il path è da interpretarsi come relativo al classpath: viene concatenato ai vari
percorsi di quest’ultimo
Java (bucci/sassoli)
93
Classi-Ereditarietà
•
Niente ereditarietà multipla
•
Keyword “extends”
– class Figlio extends Padre {}
• La classe Figlio è una sottoclasse dalla classe Padre
•
Keyword “abstract”
– abstract class Astratta {}
• La classe Astratta non può essere istanziata
– abstract void Metodo();
• Il metodo astratto Metodo rende non istanziabile la classe che lo definisce
Java (bucci/sassoli)
94
.. Classi- Ereditarietà
•
•
•
Faremo un esercizio quasi completo, che illustrerà oltre all’ereditarietà anche il
meccanismo dei package (e la documentazione con Javadoc).
Le classi vengono tutte messe nel package it.unifi.dsi.Bucci
Si usano i nomi completamente specificati (fully qualified)
•
Supponiamo che si abbia questa questa classe (definiremo tra un po’ i metodi)
class Ora {
int ore; int minuti; int secondi;
public void setOra(int ore, int minuti, int secondi) ;
public final int getOre() ;
Non possono esser modificati
public final int getMinuti() ;
essendo final
public final int getSecondi() ;
public void tick() ;
}
Nota: Questo esempio è adattato da uno presente sul libro di Sciabarrà (disponibile in rete)
Java (bucci/sassoli)
95
... La classe Ora
//: Ora.java
package it.unifi.dsi.Bucci;
// Definizione della classe Ora
/** La
*@see
*/
public
int
}
classe Ora aggiorna i secondi (e, se serve, i minuti e l'ora) ad ogni tick
OraPrecisa
class Ora {
ore, minuti, secondi;
public void setOra(int ore, int minuti, int secondi) {
this.ore= (ore <0 || ore >24) ? 0 : ore;
this.minuti= (minuti<0 || minuti > 60) ? 0 : minuti;
this.secondi= (secondi<0 || secondi >60) ? 0 : secondi;
}
public final int getOre() { return ore; }
public final int getMinuti() { return minuti; }
public final int getSecondi() { return secondi; }
public void tick() {
if(++secondi==60) {
secondi=0; if(++minuti==60){
minuti=0; if(++ore==24) ore=0;}}}
Java (bucci/sassoli)
96
... La classe OraPrecisa
//: OraPrecisa.java
package it.unifi.dsi.Bucci;
// La classe OraPrecisa derivata da Ora
// Essa gestisce anche i centesimi di secondo
public class OraPrecisa extends Ora {
private int centesimi;
public OraPrecisa() {
Costruttore della superclasse
super();
centesimi = 0;
}
public void setOra(int o, int m, int s, int c) {
super.setOra(o, m, s);
metodo della superclasse
centesimi= (c <0 || c >99) ? 0 : c;
}
public final int getCentesimi() { return centesimi; }
public void tick() {
if(++centesimi==100) { centesimi=0; super.tick(); }
}
}
Il tick è dato qui per i
centesimi per il resto in Ora
Java (bucci/sassoli)
97
La classe ProvaOra
//: ProvaOra.java
package it.unifi.dsi.Bucci;
/**
per la prova di Ora
*/
public class ProvaOra {
public static void main (String argv[]) {
Ora h = new Ora();
h.setOra(11,112,10);
System.out.println("Ore: " + h.ore +":" + h.minuti + ":" + h.secondi);
for (int i=0; i<3; i++) {
h.tick();
System.out.println("Ore: " + h.getOre() +":" + h.minuti + ":" + h.secondi);
}
OraPrecisa hp = new OraPrecisa();
hp.setOra(333,10,7,97);
System.out.println("OrePrec: " + hp.ore +":" + hp.minuti + ":" + hp.secondi + ":"
+ hp.getCentesimi());
for (int i=0; i<4; i++) {
hp.tick();
System.out.println("OrePrec: " + hp.ore +":" + hp.minuti + ":" + hp.secondi
+ ":" + hp.getCentesimi());
}
}
}
Java (bucci/sassoli)
98
Package, cartelle e altro ….
•
La cartella di lavoro è Ora. In essa ci sono tre sottocartelle e i file .bat per semplificare
le fasi di comando
Java (bucci/sassoli)
99
Percorso
•
I file sorgente sono nella cartella Src\it\unifi\dsi\Bucci
•
In tutti i file c’è:
•
Per compilare è stato costruito il file di comando
Java (bucci/sassoli)
package it.unifi.dsi.Bucci;
compile.bat nella cartella Ora
100
Compilazione
Compile.bat
cd src
javac -d ../bin it/unifi/dsi/Bucci/*.java
cd ..
–Cliccando su compile.bat
I file .class finiscono nella cartella bin/it/unifi/dsi/Bucci
del comando viene creata da javac)
Java (bucci/sassoli)
(se non esiste all’atto
101
.. Esecuzione
Per l’esecuzione c’è il file run.bat
cd bin
java it/unifi/dsi/Bucci/ProvaOra
cd ..
Ore: 11:0:10
Ore: 11:0:11
Ore: 11:0:12
Ore: 11:0:13
OrePrec: 0:10:7:97
OrePrec: 0:10:7:98
OrePrec: 0:10:7:99
OrePrec: 0:10:8:0
OrePrec: 0:10:8:1
Java (bucci/sassoli)
102
.. Documentazione
File documenta.bat:
cd src
javadoc -d ../Docs it/unifi/dsi/Bucci/*.java
cd ..
Mantiene la stessa
struttura
In questi non c’è niente
Java (bucci/sassoli)
103
.. Documentazione
Questo viene dal
*@see OraPrecisa
Java (bucci/sassoli)
104
I/O
(Fino a questo punto abbiamo solo stampato)
•
Il modo di trattate l’I/O è questo
tr
S
t
pu
t
Ou
dati
Programma
Java
Programma
Java
Java (bucci/sassoli)
Dispositivo
di uscita
m
ea
Dispositivo
di ingresso
ea
r
t
tS
u
p
in
m
105
..I/O
•
Nel caso dell’output su standard out le cose sono semplici:
– System.out (lo standard output) è un PrintStream, che a sua volta è un
OutputStream
PrintStream presenta alcuni metodi, tra cui println(String s) che abbiamo usato
•
Nel caso dell’ingresso le cose sono un po’ più complicate: Per rappresentare il flusso
di ingresso da tastiera Java prevede un oggetto BufferedInputStream
System.in (lo standard input) è un InputStream
– Si costruisce un oggetto BufferedInputStream che modella un flusso di dati che
proviene da tastiera o da rete (per questo si si serve di
– Si costruisce l’oggetto InputStreamReader per modellare un flusso di caratteri (adatto a
formare Stringhe)
– Si usa InputStreamReader per costruire l’oggetto BufferedReader al quale si può
inviare il messaggio readLine() per leggere una riga come stringa di caratteri
Java (bucci/sassoli)
106
..I/O (Input)
•
Da Tastiera
Tastiera
(System.in)
InputStream
isr
InputStreamReader
keyb
BufferedReader
•
(AppenaCreato)
(Appena Creato)
Nel caso di ingresso da file le cose sono simili; al posto della classe InputStream si
deve usare la classe FileInputStream
Java (bucci/sassoli)
107
..I/O (input da tastiera)
•
Esempio:
import java.io.*;
.. .. .. .. ..
InputStreamReader
isr;
BufferedReader
keyb;
String
Inputline;
//modella una tastiera che legge un
//flusso di caratteri
//modella una tastiera che legge
//le linee come String
//Modella una linea di ingresso
isr = new InputStreamReader(System.in);
keyb = new BufferedReader(isr);
Inputline = keyb.readLine();
Java (bucci/sassoli)
108
Ingresso di interi
Interi:
Occorre trasformare la stringa in un numero intero.
Si usa il metodo static parseInt(String s) della classe Integer
String s = keyb.readLine();
int i = Integer.parse.Int(s);
Più sinteticamente
int i = Integer.parse.Int(keyb.readLine());
•
Per funzionare la linea deve poter essere trasformata in intero altrimenti si ha errore
(exception): occorre il throws
public int read(BufferedReader br) throws Exception {
int dato = Integer.parse.Int(br.readLine());
return(dato);
}
Java (bucci/sassoli)
109
Ingresso Float, Double
•
•
•
Non c’è un parse.Double, né un parse.Float
si crea un oggetto Double (oggetto, non valore primitivo)
si manda all’oggetto il messaggio doubleValue()
String s = keyb.readLine();
Double d = Double.valueOf(s);
double x = d.doubleValue();
//ValueOf: metodo statico di Double
Ovvero:
double x = Double.valueOf(s).doubleValue();
Meglio ancora:
double x = Double.valueOf(keyb.readLine()).doubleValue();
Mostruoso:
double x = Double.valueOf(new BufferedReader(new InputStreamReader(System.in)).readLine()).doubleValue();
Java (bucci/sassoli)
110
Ora con ingresso
public class ProvaOra {
static int get(String s) throws Exception {
InputStreamReader
isr;
BufferedReader keyb;
isr = new InputStreamReader(System.in);
keyb = new BufferedReader(isr);
System.out.println(s); inl = keyb.readLine();
return Integer.parseInt(inl);
}
String inl;
public static void main (String argv[]) throws Exception{
int ora, min, sec, cent;
Ora h = new Ora();
ora = get("Batti l'ora"); min = get("Batti i minuti"); sec = get("Batti
i secondi");
h.setOra(ora, min, sec);
System.out.println("Ore: " + h.ore +":" + h.minuti + ":" + h.secondi);
……Come prima
Java (bucci/sassoli)
111
Polimorfismo
•
•
•
Java effettua Utilizza il dynamic binding (late binding): al tempo di esecuzione si
determina quale è lo specifico metodo (il codice) da eseguire.
Il polimorfismo richiede le classi astratte
Keyword “abstract”
– abstract class Astratta {}
•
La classe Astratta non può essere istanziata, anche se nessuno dei suoi metodi è astratto
– abstract void Metodo();
•
•
•
Il metodo astratto Metodo rende non istanziabile la classe che lo definisce
Una sottoclasse di una classe astratta può essere istanziata se ridefinisce tutti i
metodi della superclasse e fornisce l’implementazione di ciascuno di essi
Una sottoclasse che non implementa tutti i metodi della classe astratta da cui deriva è
essa stessa una classe astratta e non può essere istanziata.
Java (bucci/sassoli)
112
Classi astratte: esempio
//: ProvaForme.java
// Polimorfismo in Java
abstract
public
public
public
}
class Forma {
abstract double area();
abstract double perimetro();
abstract void presente() ;
•
…SEGUE
•
Notare che i metodi astratti non hanno un corpo definito. Dopo le parentesi c’è “;”
Java (bucci/sassoli)
113
.. Classi astratte: esempio
class Cerchio extends Forma {
protected double r;
protected static final double PI = 3.14;
public Cerchio() {r=1.0;}
public Cerchio(double r) {this.r = r;}
public double area() {return PI * r * r;}
public double perimetro() {return 2* PI * r;}
public double getR() {return r;}
public void presente() {
System.out.println("Cerchio.presente()"); }
}
//costante
//costruttore
//costruttore
class Rettangolo extends Forma {
protected double b, h;
public Rettangolo() {b=1.0; h=0.0;}
public Rettangolo(double b, double h) {this.b = b; this.h= h;}
public double perimetro() {return 2 * (b+h);}
public double area() {return b * h;}
public double getB() {return b;}
public double getH() {return h;}
public void presente() {
System.out.println("Rettangolo.presente()"); }
}
Java (bucci/sassoli)
SEGUE
114
.. Classi astratte: esempio
public class ProvaForme {
public static void main (String argv[]) {
Forma[] Forme = new Forma[4];
Forme[0] = new Cerchio();
Forme[0].presente(); //prenderà il metodo di cerchio
Forme[1] = new Cerchio(3.0);
Forme[2] = new Rettangolo();
Forme[3] = new Rettangolo(6.1, 7.9); Forme[3].presente(); //metodo di rettangolo
double AT = 0;
double PT = 0;
for (int i=0; i<Forme.length; i++) {
AT = AT + Forme[i].area();
PT += Forme[i].perimetro();
}
System.out.println("Area Totale: " + AT);
System.out.println("Perimetro Totale: " + PT);
// double B = Forme[2].getB();
}
ERRORE: non è in Forma
}
Java (bucci/sassoli)
115
Interfacce
•
•
In Java non c’è l’ereditarietà multipla
Il meccanismo delle interfacce consente una sorta di derivazione multipla, ma senza i
problemi che essa comporta
•
Un’interfaccia dice come si comporta una classe che la implementa
•
“Un’interfaccia fornisce un’interfaccia” (è un reference type)
•
Le interfacce sono classi puramente astratte
– servono come definizione dei metodi, tutti senza corpo e tutti astratti anche se non si
dichiarano abstract; tutti i metodi di un’interfaccia sono implicitamente definiti public
– possono contenere dati, ma questi sono implicitamente static e final cioè costanti
di classe
Java (bucci/sassoli)
116
Dichiarazione
•
•
Il corpo contiene definizioni di costanti e di metodi
I metodi NON hanno corpo: sola definizione
final String _nome = “pincopallino”;
void unmetodo(String s, int i); //senza
Java (bucci/sassoli)
117
Interfacce
•
Keyword “interface”
interface Disegnabile {
void draw(Window w);
}
•
Keyword “implements”
class RettangoloDisegnabile implements Disegnabile {
void draw(Window w) {...} //implementazione del metodo
}
•
La classe Rettangolo per essere istanziabile deve implementare tutti i metodi di Disegnabile
Java (bucci/sassoli)
118
..Interfacce
•
•
Supponiamo che le nostre forme debbano essere disegnabili
Potremmo definire una classe astratta Disegnabile, con i metodi adatti per il
disegno e derivare le classi CerchioDisegnabile, RettangoloDisegnabile,
etc.
– Equivale a buttare via il lavoro precedente
•
Supponiamo che si vogliano ancora i metodi area e perimetro, ma non si voglia
riscriverli. Non è possibile rendere CerchioDisegnabile sottoclasse di
Disegnabile e di Cerchio: in Java l’eredità multipla non è consetita
•
Tuttavia possiamo:
– Definire un’interfaccia Disegnabile;
– Derivare CerchioDisegnabile da Cerchio
– Fare implementare a CerchioDisegnabile l’interfaccia Disegnabile
Java (bucci/sassoli)
119
..Interfacce: esempio
•
L’interfaccia Disegnabile
// : Disegnabile.java
public interface Disegnabile {
void draw();
void setColor(Color c);
void setPosizione(double x, double y);
}
Java (bucci/sassoli)
120
..Interfacce: esempio
//: ProvaFormeDis.java
class CerchioDisegnabile extends Cerchio implements Disegnabile {
private double x, y; //posizione
private Color c;
//colore
public CerchioDisegnabile(double r) {super(r);}
// costruttore
// implementazione dei metodi dell'interfaccia
public void setColor(Color c) {this.c =c;}
public void setPosizione(double x, double y) {this.x = x; this.y = y;}
public void draw() {
System.out.println("CerchioDisegnabile.draw(); Colore:" + c.k + ";
Posizione: " + x +","+y);
}
Implementazione dei metodi di interfaccia. Sono
ereditati i metodi della superclasse
}//CerchioDisegnabile
•
SEGUE
Java (bucci/sassoli)
121
// SEGUE
ProvaFormeDis.java
class RettangoloDisegnabile extends Rettangolo implements Disegnabile {
private double x, y;
private Color c;
public RettangoloDisegnabile(double b, double h) {super(b, h);}
costruttore
//
// implementazione dei metodi dell'interfaccia
public void setColor(Color c) {this.c =c;}
public void setPosizione(double x, double y) {this.x = x; this.y = y;}
public void draw() {
System.out.println("RettangoloDisegnabile.draw(); Colore:" + c.k +
"; Posizione: " + x +","+y);
}
} //RettangoloDisegnabile
Java (bucci/sassoli)
122
// SEGUE
ProvaFormeDis.java
class Color {
//il colore
int k;
Color(int k) {this.k= k;}
}
Java (bucci/sassoli)
123
// SEGUE
ProvaFormeDis.java
public class ProvaFormeDis{
public static void main (String argv[])
{
Forma[] Forme = new Forma[2];
//vettore di forme (non disegnabili)
Disegnabile[] Disegnabili = new Disegnabile[2];
//vettore di
disegnabili
CerchioDisegnabile Cd = new CerchioDisegnabile(5.5);
RettangoloDisegnabile Rd = new RettangoloDisegnabile(10,10);
Forme[0] = Cd;
Forme[1] = Rd;
double AT = 0.;
Disegnabili[0] = Cd;
Disegnabili[1] = Rd;
double PT = 0.;
for (int i= 0; i<Forme.length; i++) {
AT = AT + Forme[i].area();
PT += Forme[i].perimetro();
Disegnabili[i].setPosizione(i*10.0, i*5.0);
Disegnabili[i].setColor(new Color(i));
Disegnabili[i].draw();}
System.out.println("Area Totale: " + AT);
System.out.println("Perimetro Totale: " + PT);
Java (bucci/sassoli)
} }
124
Interfacce multiple
•
•
Si può derivare da una sola classe, ma si possono avere quante interfacce si vogliono
L’interfaccia non ha associata memoria (eccetto le costanti) e quindi non si pongono
problemi come nel caso dell’ereditarietà multipla del C++
Classe base
astratta o concreta
interface 1
interface 2
interface n
Classe derivata
•
implem. 1
implem. 2
.…
implem. n
Da un’interfaccia si può derivare una nuova interfaccia, come pure derivare
l’interfaccia da più di una interfaccia
Java (bucci/sassoli)
125
Interfacce multiple: forme disegnabili e colorabili
// : DisegnabileEcolorabile.java
interface Disegnabile {
void draw();
void setPosizione(double x, double y);
}
interface Colorabile{
void modColor();
}
Java (bucci/sassoli)
126
….forme disegnabili e colorabili
//: DisegnabiliEColorabili
class CerchioDiscolo extends Cerchio implements Disegnabile, Colorabile {
private double x, y;
private Color c;
public CerchioDiscolo(double r, Color c) { super(r);
this.c =c;
System.out.println("CerchioDiscolo: Colore Iniziale: " + c.k);
}
// costruttore
public void setPosizione(double x, double y) {this.x = x; this.y = y;}
public void draw() {
System.out.println("CerchioDiscolo.draw(); Posizione: " + x +","+y
+ "
Colore:" + this.c.k );
}
public void modColor() {++this.c.k;
System.out.println("CerchioDiscolo.modColor(); Colore:" + this.c.k
);
}
}//CerchioDiscolo
Java (bucci/sassoli)
127
Trattamento degli errori (Exception handling)
•
•
Simile al C++
Terminologia:
– Exception: un segnale che indica che si è verificata qualche condizione eccezionale (per
esempio un errore, una divisione per 0)
– To throw an exception: segnalare che si è verificata la condizione eccezionale
– To cactch an exception: trattare la cosa prendendo i provvedimenti adeguati
•
•
Quando si verifica l’eccezione il contesto corrente viene abbandonato, l’eccezione si
propaga attraverso la struttura a blocchi. Se non viene catturata dal blocco di codice
che la ha determinata, l’eccezione si propaga a livello superiore (al metodo
chiamante) e così via. Alla fine arriva al main e se non viene catturata, l’interprete
stampa un messaggio di errore, la traccia dello stack ed abbandona il programma
Il meccanismo delle eccezioni consente di localizzare in un unico punto il trattamento
delle condizioni anomale
Java (bucci/sassoli)
128
Exception handling
•
Il meccanismo si basa su try/catch/finally:
• try: definisce il blocco di codice che può avere eccezioni al suo interno
try { /* codice che potrebbe generare eccezioni */}
• catch: una o più clausole catch possono seguire il blocco try.
Il codice nel catch deve svolgere le azioni ritenute appropriate per trattare l’eccezione
Hanno un argomento che deve essere di tipo Throvable (o derivato): in presenza di
un’eccezione viene invocata la prima clausola catch che ha un argomento dello
stesso tipo.
(non è necessario avere un catch per tutte le possibili eccezioni)
catch (UnEccezione e1){ /* tratta l’oggetto e1 di tipo
UnEccezione o sua sottoclasse*/}
catch (AltraEccezione e2){ /* tratta l’oggetto e2 di tipo
AltraEccezione o sua sottoclasse*/}
catch (FileNotFoundException e) {/* potrebbe chiedere
di ribattere il nome del file*/ }
Java (bucci/sassoli)
129
STRUTTURA try-catch-finally
try
blocco-0
catch (exception_type1 id)
blocco-1
catch (exception_type2 id)
block-2
…
finally
blocco-n
qui dentro viene
segnalata la eccezione,
con throw e
blocco-0
exception_type1
exception_type2
blocco-1
blocco-2
blocco-n
Java (bucci/sassoli)
130
LA SEGNALAZIONE DELLE ECCEZIONI
Le eccezioni possono venire segnalate:
• dal sistema run-time, es.:
ArithmeticException
IndexOutOfBoundsException
SecurityException
NullPointerException
...
• dal programma:
throw e;
Java (bucci/sassoli)
131
CHE COSA SONO LE ECCEZIONI
• Le eccezioni sono oggetti, di una sottoclasse della classe Throwable:
Object
Throwable
Exception
Error
unchecked
exceptions
Runtime
Exception
unchecked
exceptions
Java (bucci/sassoli)
checked exceptions,
definite dall’utente
132
Exception objects
•
Un’eccezione è un oggetto istanza di una qualche sottoclasse di
java.lang.Throvable.
•
Throvable ha due sottoclassi standard: java.lang.Error e java.lang.Exception
•
Le eccezioni sono sottoclassi di Exception e rappresentano condizioni che possono
essere rilevate e rimediate. Ad esempio java.io.EOFException segnala la fine di un
file
Java (bucci/sassoli)
133
Exception objects
•
•
•
•
Poiché le eccezioni sono oggetti, esse possono contenere dati e metodi: Throvable
ha un campo che è un messaggio (String), ereditato da tutte le classi eccezione.
Questo campo viene usato per scriverci informazioni in forma leggibile
L’informazione da scrivere nel campo viene passata al costruttore dell’oggetto
eccezione
Il messaggio può essere letto con il metodo Throvable.get.Message()
Normalmente le eccezioni hanno questo solo campo. L’eccezione
java.io.InterruptedIOxception ha il campo public int byte transferred,
che specifica quanta parte del trasferimento ha avuto luogo prima dell’eccezione
Java (bucci/sassoli)
134
.. Exception handling
• finally: blocco usato di norma per le operazioni di pulizia (chiusura file, rilascio
risorse, etc..) dopo un blocco try. Java garantisce che il finally è sicuramente
eseguito se viene eseguito (anche parzialmente) il blocco try, indipendentemente da
come si conclude.
– Se il controllo lascia il try per effetto di break, continue o return il blocco finally è
eseguito prima di passare alla nuova destinazione
– Se il controllo lascia il try per un’eccezione e
• c’è un catch: prima viene eseguito il catch e poi il finally.
• non c’è il blocco catch: il controllo passa al finally e poi si propaga ai blocchi
superiori verso il catch più prossimo che può trattare l’eccezione
•
Il finally può essere usato anche senza le eccezioni e il catch. In questo caso il
finally è comunque eseguito (che si esca o no con break, continue o
return) e assume il ruolo di pulizia al termine del blocco try
Java (bucci/sassoli)
135
Dichiarazione delle eccezioni
•
Ogni metodo che può generare eccezioni deve o catturarle a suo interno o specificare
il tipo di eccezioni che lo fanno terminare (che esso lancia):
public void open_file() throws IOException{
/* istruzioni che possono generare una eccezione di IO non
catturata entro open_file() */
}
public void mioMetodo() throws MiaEccez1, MiaEccez2 {
/* istruzioni che possono generare eccezioni di tipo
MiaEccez1, MiaEccez2 non catturata entro mioMetodo()*/ }
•
E’ possibile segnalare una eccezione definita dal programmatore attraverso il
comando throw seguito da un oggetto che un Throvable o sua sottoclasse
if (t == null)
throw new NullPointerException(“t è un puntatore nullo”)
Java (bucci/sassoli)
136
Esempio
//: ExceptionMethods.java
public class ExceptionMethods {
public static void main(String[] args) {
try {
throw new Exception("Ecco la mia eccezione");
}
catch(Exception e) {
System.out.println("Eccezione Catturata!");
System.out.println(
"e.getMessage(): " + e.getMessage());
System.out.println(
"e.toString(): " + e.toString());
System.out.println("e.printStackTrace():");
e.printStackTrace();
}
}
}
Eccezione Catturata!
e.getMessage(): Ecco la mia eccezione
e.toString(): java.lang.Exception: Ecco è la mia eccezione
e.printStackTrace():
java.lang.Exception: Ecco la mia eccezione
at ExceptionMethods.main(ExceptionMethods.java:6)
Java (bucci/sassoli)
137
Esempio throw
class Tabella {
int n; int [] a;
…..…
void inserisci(int x)
{
if (n >= a.length - 1)
throw new RuntimeException("tabella piena");
.........
public static void main (String [] args) {
Tabella t = new Tabella(2);
t.inserisci(5); t.inserisci(8);
......
Runtime exception: tabella piena
at Tabella.inserisci ...
at Tabella.main .....
Java (bucci/sassoli)
138
Esempio try-catch
//Catturare le eccezioni
class Tabella {
int n; int [] a;
void inserisci(int x) {
if (n >= a.length - 1)
throw new RuntimeException("tabella piena");
.........
public static void main (String [] args) {
Tabella t = new Tabella(2);
try {
t.inserisci(5);
t.inserisci(8);
} catch(RuntimeException e) {
System.out.println(e. getMessage());
}
Java (bucci/sassoli)
139
Guardiamo la documentazione
cartella DOCS
java.lang
Class NullPointerException
java.lang.Object
|
+--java.lang.Throwable
|
+--java.lang.Exception
|
+--java.lang.RuntimeException
|
+--java.lang.NullPointerException
•
•
Thrown when an application attempts to use null in a case where an object is required. These
include:
•
Calling the instance method of a null object.
•
Accessing or modifying the field of a null object.
•
Taking the length of null as if it were an array.
•
Accessing or modifying the slots of null as if it were an array.
•
Throwing null as if it were a Throwable value.
Applications should throw instances of this class to indicate other illegal uses of the null
object.
Java (bucci/sassoli)
140
... Guardiamo la documentazione
Constructor Summary
– NullPointerException()
Constructs a NullPointerException with no detail message.
– NullPointerException(String s)
Constructs a NullPointerException with the specified detail message.
•
Methods inherited from class java.lang.Throwable
• fillInStackTrace, getLocalizedMessage, getMessage,
printStackTrace, printStackTrace, printStackTrace, toString
•
Bla, bla ..
Java (bucci/sassoli)
141
MULTITHREADING
CHE COS’E’ IL MULTITHREADING
• Thread: flusso sequenziale di controllo (esecuzione di istruzioni) in un programma.
• Nello stesso programma si possono far partire più thread che sono eseguiti
concorrentemente.
• Tutti i thread condividono le stesse variabili del programma, a differenza dai processi
che hanno ciascuno il proprio contesto (lightweight process).
• Nei computer a singola CPU la concorrenza viene simulata con una
politica di scheduling che alterna l'esecuzione dei singoli thread.
Java (bucci/sassoli)
143
CHE COS’E’ IL MULTITHREADING
• Una applicazione Java che usa i thread può eseguire più attività
contemporaneamente. Esempio: aggiornare l'informazione grafica sullo schermo e
accedere alla rete.
• Ad esempio, quando un main crea una finestra, viene attivato un thread di interfaccia
utente, diverso da quello del main.
• In alcuni casi i thread possono procedere in modo indipendente uno dall'altro
(comportamento asincrono), in altri devono essere sincronizzati fra loro (es. produttore
- consumatore).
Java (bucci/sassoli)
144
MULTITASKING E MULTITHREADING
Multitasking
Multithreading
OS
OS
OS
OS
Task
Task
11
Task
Task
22
Task
Task
11
Task
Task
33
Task
Task
22
Monitor
Monitor
(interprete
(interpreteJava)
Java)
Memoria
condivisa
Memoria
condivisa
Thread
Thread
11
Memoria locale
Thread
Thread
22
Thread
Thread
33
Memoria
condivisa
Memoria locale
Memoria locale
Java (bucci/sassoli)
145
RUN-TIME DATA AREA
Thread 1
Thread 2
Thread n
Program
Counter
Stack
….
variabili locali,
ecc. dei metodi
Heap
oggetti condivisi fra i thread,
creati dinamicamente
e garbage collected
Method
Area
Java (bucci/sassoli)
qui vengono caricati dal class loader i files
.class, contenenti la descrizione della
classe (campi, metodi, ecc.)
146
LA CLASSE Thread
In Java, ogni thread è un oggetto:
• ogni singolo thread viene creato come una istanza della classe java.lang.Thread
• ogni istanza di java.lang.Thread deve essere associata a un metodo run() di qualche
classe, che contiene il codice che deve essere eseguito dal thread
• la classe java.lang.Thread contiene tutti i metodi per la gestione dei thread
• … e in particolare il metodo start(), per “lanciare” il thread con il metodo run()
“opportuno”
Java (bucci/sassoli)
147
LA CLASSE Thread: SCHEMA
“lancia”
“lancia”ililthread,
thread,rendendolo
rendendoloschedulaschedulabile.
Esegue
il
metodo
run()
del
bile. Esegue il metodo run() delThread,
Thread,
che
a
sua
volta
lancia
il
metodo
che a sua volta lancia il metodorun()
run()
dell’oggetto
passato
come
parametro
dell’oggetto passato come parametro
alalcostruttore
costruttoreThread(),
Thread(),oppure
oppure(se
(se
Thread
non
ha
parametri)
non
fa
nulla.
Thread non ha parametri) non fa nulla.
public class Thread implements Runnable
Runnable target;
….
public syncronized native void start() {
… run();
}
public void run() { if (target != null) { target.run(); } }
Thread (Runnable t) { target = t; …. }
}
public interface Runnable {
public abstract void run();
}
Java (bucci/sassoli)
148
COME REALIZZARE UN THREAD
Ci sono due metodi per realizzare un thread:
Metodo 1:
Metodo 2:
run()
implementando la interfaccia Runnable
estendendo la classe java.lang.Thread
Java (bucci/sassoli)
e sovrascrivendo
149
METODO 1
public interface Runnable {
public abstract void run();
}
class Application implements Runnable {
public void run() { <body> }
}
...
Application a = new Application(); /* creo l’Application a il cui
metodo run() dovrà essere
eseguita in un thread */
Thread th = new Thread(a);
/* creo un thread e gli passo il
riferimento all’Application a */
th.start();
/* lancio il thread, eseguendo il
metodo a.run() */
Java (bucci/sassoli)
150
ESEMPIO 1.1
public class drinks {
public static void main(String[] a) {
Coffee c = new Coffee(); Tea t = new Tea();
Thread th1 = new Thread(c) ; th1.start();
Thread th2 = new Thread(t) ; th2.start() ;
In questo esempio,
un main crea
}
}
e lancia i thread
class Coffee implements Runnable {
public void run() {
while(true) { System.out.println(“I like coffee”);}
}
}
class Tea implements Runnable {
public void run() {
while(true) { System.out.println(“I like tea”);}
}
}
Java (bucci/sassoli)
151
ESEMPIO 1.2
public class drinks {
public static void main(String[] a) {
Coffee c = new Coffee(); Tea t = new Tea() ;
}
}
class Coffee implements Runnable {
In questo esempio, ogni
Thread th;
oggetto crea e lancia
il proprio thread
public void run() {
while(true) { System.out.println(“I like coffee”);}
}
Coffee() { th = new Thread(this) ; th.start(); }
}
class Tea implements Runnable {
Thread th;
public void run() {
while(true) { System.out.println(“I like tea”);}
}
Tea() { th = new Thread(this) ; th.start() ; }
}
Java (bucci/sassoli)
152
METODO 2
class Thread implements Runnable {
public void start() { …
run();
}
public void run() { }
}
class MyThread extends Thread {
// eredita start()
public void run() { < body> }
}
sovrascrive
MyThread p = new MyThread();
p.start();
Java (bucci/sassoli)
153
ESEMPIO 2.1
public class drinks {
public static void main(String[] a) {
Coffee th1=new Coffee(); th1.start();
In questo esempio,
Tea th2=new Tea() ; th2.start();
un main crea
}
}
e lancia i thread
class Coffee extends Thread {
public void run() {
while(true) { System.out.println(“I like coffee”);}
}
}
class Tea extends Thread {
public void run() {
while(true) { System.out.println(“I like tea”);}
}
}
Java (bucci/sassoli)
154
ESEMPIO 2.2
public class drinks {
public static void main(String[] a) {
Coffee th1=new Coffee(); Tea=th2 new Tea() ;
}
}
class Coffee extends Thread {
public void run() {
while(true) { System.out.println(“I like coffee”);}
}
Coffee() { start(); }
}
class Tea extends Thread {
In questo esempio,
public void run() {
ogni thread si lancia
while(true) { System.out.println(“I like tea”);}
da solo
}
Tea() { start(); }
}
Java (bucci/sassoli)
155
QUANDO UN thread TERMINA?
Un thread continua nella sua esecuzione, fino a quando:
1.
run() ritorna
2.
viene eseguito il metodo stop() del thread
3.
una eccezione causa l’uscita da run()
Java (bucci/sassoli)
156
SCHEDULING
• lo scheduling è effettuato sulla base della priorità dei thread
• la priorità può essere modificata mediante il metodo setPriority
• a parità di priorità, lo scheduling è di tipo round-robin
Java (bucci/sassoli)
157
ALCUNI METODI DI Thread
public void start()
public void run()
public final void stop()
public final void suspend()
public final void resume()
public static void sleep(long n)
public final void setPriority(int newPriority)
public final int getPriority()
public static void yield()
public final native boolean isAlive()
...
Java (bucci/sassoli)
lancia il thread
esegue il codice
distrugge il thread
sospende il thread
riattiva il thread
sospende il thread
per n msec
modifica la priorità
ottieni la priorità
rischedula
true se il thread è vivo
158
GLI STATI DI UN THREAD
yield()
new Thread()
New
New
thread
thread
start()
Alive
suspend()
sleep()
wait()
Runnable
Runnable
resume()
notify()
stop()
stop()
run() exit
Not
Not
Runnable
Runnable
stop()
Dead
Dead
Java (bucci/sassoli)
159
IL PROBLEMA DELLA MUTUA ESCLUSIONE
i=0
thread 1
thread 2
class Count {
int i = 0;
void incr() {
i+1
i = i + 1;
}
void decr() {
i = i - 1;
}
1
i -1
-1
i=1
i = -1
}
Il valore finale di i dipende dalla sequenza di esecuzione
Java (bucci/sassoli)
160
METODI synchronized
Il modificatore synchronized prescrive che il metodo a cui si applica sia eseguito da un
solo thread alla volta:
- quando un thread esegue un metodo synchronized, viene fatto un lock dell’oggetto
cui appartiene il metodo (o, per metodi static, della classe)
- quando il thread termina l’esecuzione del metodo, viene fatta una unlock
- prima di tale unlock, eventuali altri metodi synchronized si pongono in attesa
Java (bucci/sassoli)
161
ESEMPIO
i=0
thread 1 thread 2
class Count {
int i = 0;
synchronized void incr() {
i = i + 1;
i+1 1
i=1
}
synchronized void decr() {
i = i - 1;
i -1 0
i=0
}
}
Il valore finale di i NON dipende dalla sequenza di esecuzione
Java (bucci/sassoli)
162
BLOCCHI synchronized
• La keyword synchronized può essere usata anche per proteggere blocchi arbitrari, e
non solo metodi
• in tal caso, occorre specificare l’oggetto di cui acquisire il lock
Esempio:
synchronized ( myObject ) { <blocco> }
Java (bucci/sassoli)
163
ESEMPIO
synchronized void MyMethod() {
…
}
è equivalente a:
void MyMethod() {
synchronized (this) {
…
}
}
Java (bucci/sassoli)
164
ESEMPIO
import java.util.Vector;
public class MsgQueue {
Vector queue = new Vector();
public synchronized void send(Object obj) {
queue.addElement(obj);
}
public synchronized Object receive() {
if (queue.size() == 0) return null;
Object obj = queue.firstElement();
queue.removeElementAt(0);
return obj;
}
}
Java (bucci/sassoli)
165
wait, notify
Sono metodi della classe Object:
public final void wait();
public final void wait(long millis);
public final void notify();
Java (bucci/sassoli)
/* rilascia il lock e si pone in wait */
/* wait con timeout */
/* rilascia il lock */
166
ESEMPIO
Schema Produttore-Consumatore
// Thread produttore: produce un dato
while (buffer_full) wait()
produce_data()
notify()
// Thread consumatore: consuma un dato
while (no_data) wait()
consume_the_data()
notify()
Java (bucci/sassoli)
167
JAVA E INTERNET
Java (bucci/sassoli)
168
APPLET JAVA
• Sono programmi Java riferiti da link in pagine HTML
• Vengono caricati e interpretati dal browser (se questo supporta Java)
• Permettono di “animare” le pagine web
Java (bucci/sassoli)
169
HTML con APPLET: ESEMPIO
<HTML>
<HEAD>
<TITLE> Esempio </TITLE>
</HEAD>
<BODY>
<P>
Testo
<APPLET
CODE=“HelloWorld.class WIDTH=300 HEIGHT=80>
Qui c’è un applet che ti saluta
</APPLET>
testo che esce se il browser
</BODY>
non supporta gli applet
</HTML>
Java (bucci/sassoli)
Hallo!
170
Applet
•
Dove si trova la classe Applet nella gerarchia di java
java.applet
Class Applet
java.lang.Object
|
+--java.awt.Component
|
+--java.awt.Container
|
+--java.awt.Panel
|
+--java.applet.Applet
Java (bucci/sassoli)
171
Alcuni metodi di Applet
Method Operation
void init( ) called when the applet is first created to perform first-time initialization of the applet
(Il browser non passa alcun argomento a costruttore dell’applet, per cui non ha molto
senso definire un costruttore diverso)
voit start( ) Called every time the applet moves into sight on the Web browser to allow the applet
to start up its normal operations (especially those that are shut off by stop( )). Also
called after init( ).
void paint( ) Part of the base class Component (three levels of inheritance up). Called as part of
an update( ) to perform special painting on the canvas of an applet.
void stop( ) Called every time the applet moves out of sight on the Web browser to allow the
applet to shut off expensive operations. Also called right before destroy( ).
void destroy( ) Called when the applet is being unloaded from the page to perform final release of
resources when the applet is no longer used
string getAppletInfo Returns information about this applet
URL getParameter() Returns the base URL (l’URL da cui è stata scaricata)
Java (bucci/sassoli)
172
Cosa serve in un Applet
•
•
•
•
•
•
Importare il package Applet e costruire una classe che estende Applet
Implementare almeno un metodo tra i seguenti
init, start, paint
I/O attraverso classi grafiche
– per esempio g.drawString("=======")
Costruire un file HTML che richiama l'Applet
Usare un browser o appletviewer
Esempio
import java.applet.Applet;
import java.awt.Graphics;
public class HelloW extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
•
Il browser chiama sempre init()
Java (bucci/sassoli)
173
Esecuzione dell’Applet
•
File html:
<comment> File:HelloW.html </comment>
<HTML>
<BODY>
<APPLET CODE=HelloW.class WIDTH=150 HEIGHT=50>
</APPLET>
</BODY>
</HTML>
•
Per eseguire:
– Cliccare su HelloW.html
– >appletviewr HelloW.html
Java (bucci/sassoli)
174
SimpleApplet
•
•
•
•
Si inizializza
Parte
Si ferma
Pulisce prima di uscire.
•
Vale la pena di farlo girare con appletviewer e osservare i messaggi che esso
presenta su System.out, in relazione a quanto accade all’applet.
Java (bucci/sassoli)
175
Simple Applet
import java.applet.Applet;
import java.awt.Graphics;
import java.awt.Color;
public class SimpleApplet extends Applet{
int i=0;
String text;
public void init() {
text = "Sono un semplice Applet: ";
setBackground(Color.cyan);
}
public void start() {
System.out.println("starting...");
}
public void stop() {
System.out.println("stopping...");
}
public void destroy() { System.out.println("preparing to unload..."); }
public void paint(Graphics g){
g.setColor(Color.blue);
g.drawRect(0, 0, 200, 100);
g.setColor(Color.red);
g.drawString(text, 30, 30);
g.setColor(Color.yellow);
g.drawString("Metodo Paint: " + i, 100, 60);
System.out.println("SPaint:" + i);
i++;
}
}
Java (bucci/sassoli)
176
SimpleApplet
Java (bucci/sassoli)
177
HelloWColorato
// Adattato da Java Examples in a Nutshell_. (http://www.oreilly.com)
import java.applet.*; import java.awt.*;
public class HelloWColorato extends Applet {
static final String message = "Hello World";
private Font font;
public void init() {// One-time initialization for the applet.
font = new Font("Helvetica", Font.BOLD, 48); }
public void paint(Graphics g) {
g.setColor(Color.pink);
g.fillOval(10, 10, 330, 100); // The pink oval
g.setColor(Color.red);
// The red outline. Java doesn't support
g.drawOval(10,10, 330, 100);
//
wide lines, so we simulate
g.drawOval(9, 9, 332, 102);
//
a 4-pixel wide line by drawing
g.drawOval(8, 8, 334, 104);
g.drawOval(7, 7, 336, 106);
g.setColor(Color.black);
g.setFont(font);
g.drawString(message, 40, 75);
}
}
Java (bucci/sassoli)
178
Sicurezza e Applet
•
Gli applet scaricati da rete sono considerati untrusted
Per questo motivo i Browser del Web e viewer mettono limitazioni
quello che un applet può fare. Un Applet scaricato da rete non può:
– Leggere, scrivere, modificare, cancellare, ridenominare i file
– listare il contenuto delle cartelle
– verificare se esiste un file
– ottenere la data o la dimensione di un file
– ..e altro
Java (bucci/sassoli)
179
... Sicurezza e Applet
•
•
Security Manager
E’ ottenuto attraverso la classe java.lang.SecurityManager la quale
definisce metodi per verificare se certe operazioni sono consentite un
dato ambiente
– Il browser lo subclassa ed aggiunge eventuali controlli e lo istanzia
come oggetto
– Il manager viene registrato con System.setSecurityManager()
– Il manager viene interrogato prima di fare cose rischiose
Class Loader
Ottenuto subclassando java.lang.ClassLoader definendo come i
file .class vengono caricati attraverso i vari protocolli.
– Le classi locali hanno un name space separato da quelle scaricate,
in modo da ottenere un trattamento diverso rispetto a quelle
scaricate da rete
Java (bucci/sassoli)
180
... Sicurezza e Applet
•
ByteCode verification
E’ sempre compito del class loader:
– Codici validi per la JVM
– Non esce dallo stack
– Non sporca i registri
– Non fa conversioni illegali
•
Classi firmate: è possibile appendere una firma digitale alle classi (ai file
JAR). Il browser può consentire lo svolgimento di azioni normalmente
negate se il file JAR è firmato (la decisione di chi accettare è specificata
dall’utente). Il JDK fornisce i servizi per la firma
Java (bucci/sassoli)
181