Linguaggio Java

Linguaggio Java
Testi consigliati:
• Claudio De Sio Cesari: Manuale di Java 8, Programmazione orientata agli oggetti con Java Standard Edition 8,
Hoepli Editore, 2014.
• Luigi Comi: Java 8 Pocket, Guida compatta alle basi del linguaggio, Apogeo, 2014.
• Slide delle lezioni.
Linguaggio Java:
Java è un un linguaggio di programmazione orientato agli oggetti, sviluppato nel 1995 da James Gosling e altri
ingegneri di Sun Microsystems ( Dal 2010 Oracle ). Attualmente, Java è uno dei linguaggi più utilizzati soprattutto
per applicazioni distribuite o di rete.
Caratteristiche principali:
 Semplicità;
 Object Oriented;
 Indipendenza dalla piattaforma (Portabilità);
 Robustezza;
 MultiThread;
 Sicurezza;
Semplicità:
La sintassi di Java è molto semplice e chiara; in fase di creazione ci si è ispirati ai linguaggi C e C++, ma sono state
eliminate tutte quelle funzionalità potenzialmente pericolose; come ad esempio i puntatori o la gestione esplicita
della memoria. Java è un linguaggio fortemente tipato.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Object Oriented:
Questa è una nuova filosofia di programmazione nata intorno agli anni '90; l’idea principale della programmazione ad
oggetti consiste nel rendere il software la rappresentazione di entità reali o astratte ma ben definite. Gli oggetti sono
degli insiemi software di dati e procedure relative, che interagiscono tra loro attraverso dei messaggi.
Per oggetto si intende un modello di programmazione software, il quale ha uno stato definito nelle variabili istanza e
un comportamento definito dai metodi.
Una classe è un prototipo (costrutto software), che definisce gli attributi (variabili) e i metodi comuni a tutti gli oggetti
di un certo tipo. Definita una classe, cioè il modello di oggetto, si possono istanziare (creare fisicamente) degli oggetti
di quel tipo, dando ad ognuno un nome a piacere.
Proprietà che caratterizzano un linguaggio Object Oriented:
Incapsulamento:
L'incapsulamento è la proprietà per cui un oggetto contiene (incapsula) al suo interno gli attributi (dati) e i metodi
(procedure) che accedono ai dati stessi. Lo scopo principale dell'incapsulamento è di rendere invisibili i dati e di gestirli
solo tramite i metodi definiti. Tale sistema permette di vedere l'oggetto come una black-box, cioè una scatola nera.
Ereditarietà:
In generale, essa rappresenta un meccanismo che consente di creare nuovi oggetti che siano basati su altri già definiti.
Le proprietà di una classe possono essere ereditate totalmente o in parte dalle sue sottoclassi che possono avere
anche altre specifiche proprietà.
La classe genitrice è detta superclasse, mentre la sottoclasse è detta classe derivata. Questo viene realizzato tramite la
parola chiave: extends.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Un oggetto della sottoclasse incapsula tutti i dati della classe genitrice più i suoi dati e può usare tutti i metodi della
superclasse risparmiando nella scrittura del codice. A differenze di altri linguaggi abbiamo l’ereditarietà singola.
Polimorfismo:
Per polimorfismo si intende la proprietà di una entità di assumere forme diverse nel tempo.
In dettaglio, all’interno di una stessa classe si possono definire più metodi con lo stesso nome ma con parametri
diversi per tipo e/o per numero; in questo caso si parla di: overloading.
Nel caso di classi derivate, si ha la possibilità di riscrivere i metodi della superclasse, attuando così l’overriding.
Indipendenza dalla piattaforma (Portabilità):
Il linguaggio Java è stato progettato per lo sviluppo di applicazioni che fossero il più possibile indipendenti dalla
piattaforma. Grazie alla presenza della JVM (Java Virtual Machine), ogni applicazione, una volta compilata, potrà
essere eseguita su una qualunque piattaforma (Windows, Linux, Mac, ecc). Il compilatore Java (javac) converte i file
sorgenti (.java) in formato bytecode, che la JVM provvederà ad interpretare ed eseguire.
Nota: La neutralità di Java rispetto all'architettura, è dovuta anche al fatto che è specificata perfettamente la
dimensione di tutti i tipi primitivi: byte, short, int, long, float, double, boolean, char; per cui il comportamento
di questi è uguale per tutte le piattaforme.
Robustezza:
Questa proprietà deriva soprattutto da una gestione delle eccezioni chiara e funzionale e da un meccanismo
automatico della gestione della memoria. Java esonera il programmatore dal compito di liberare (deallocare)
memoria quando è necessario. Durante l’esecuzione di un programma è attivo un processo (Garbace Collector) che
provvede a liberare memoria non più utilizzata.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
MultiThread:
Una delle caratteristiche fondamentali è il multithreading; una delle classi che fanno parte delle librerie standard di
Java è la classe Thread. Letteralmente thread significa filone; Java da la possibilità di dar vita a più filoni di esecuzione
(processi), che possono svolgere simultaneamente diversi compiti.
Sicurezza:
Siccome questo linguaggio è stato progettato per funzionare in ambienti distribuiti o di rete, la sicurezza rappresenta
un requisito indispensabile. Un "applet" che viene scaricato dalla rete ed eseguito localmente attraverso il browser,
potrebbe arrecare danni al sistema locale; fortunatamente la JVM installata nel browser effettua alcuni controlli e non
permette operazioni pericolose. Ovvero l’ambiente java implementa delle protezioni contro eventuali minacce.
Piattaforma Java:
La tecnologia Java consiste in un linguaggio di programmazione e una piattaforma di elaborazione sviluppati da Sun:
Java SE (Java Platform Standard Edition – attualmente versione 8).
Per realizzare applet e applicazioni Java è necessario installare lo strumento di sviluppo JDK (Java Development Kit)
scaricabile dal sito WEB di Java; esso comprende:
 Java Runtime Environment (JRE)
 Java compiler
 Java API (Application Programming Interface)
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Scrittura sorgenti:
I sorgenti Java sono dei file con estensione .java; ciascun file contiene il codice relativo ad una classe.
Da notare che il nome del file deve coincidere con il nome della classe.
Applicazioni Java: programmi "stand-alone".
Applets Java : programmi Java inseriti nelle pagine web ed eseguibili da Web browser (la JVM installata come plug-in
del browser). In alternativa possono essere eseguite utilizzando il Sun AppletViewer.
Compilazione: (Dal prompt dei comandi)
javac nomefile.java
Se la compilazione va a buon fine viene creato il file .class;
eseguibile mediante la JVM.
Esecuzione: (Dal prompt dei comandi)
java nomefile
// Primo programma in Java.
public class HelloWorld {
public static void main(String[] args) {
// stampa su video messaggio di saluto:
System.out.println("Hello World ! ");
}
}
Ambienti di sviluppo:
Lavorare dalla linea di comando è piuttosto macchinoso; cosicchè si ricorre ad ambienti di sviluppo integrati; ad esempio:
- NetBeans
- Eclipse
- Borland JBuilder
- BlueJ
- ……
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Caratteristiche del linguaggio (elementi fondamentali):
Il linguaggio java è derivato da C++, pertanto sintatticamente sono molto simili.
Identificatori:
Gli identificatori rappresentano i nomi che possono essere assegnati a variabili, metodi, classi, ecc.
Un identificatore è composto esclusivamente da lettere, numeri e i caratteri underscore (_) e dollaro ($);
non possono iniziare con una cifra. Il linguaggio Java è case-sensitive. Non si possono usare le parole chiave:
abstract
assert
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
enum
extends
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while
Nota: il punto e virgola (;) indica il termine di un’istruzione.
Commenti:
// Questo è un commento !
/* ….. Commento ….. */
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Tipi di dato:
Java è un linguaggio fortemente tipato (tipizzato) in quanto ogni variabile ed ogni espressione hanno associato un tipo.
Abbiamo due tipi di dato: tipi primitivi e tipi riferimento (reference).
Tipi primitivi:
Tipo di dato
byte
short
int
long
float
double
char
boolean
Descrizione
Numero intero a 8 bit (da -128 a 127)
Numero intero a 16 bit (da -32768 a 32767)
Numero intero a 32 bit (da –2147483648 a 2147483647)
Numero intero a 64 bit
Numero in virgola mobile a 32 bit (singola precisione)
Numero in virgola mobile a 64 bit (doppia precisione)
Singolo carattere Unicode a 16 bit
Valore logico true o false
Tipi di riferimento: sono le classi, gli array e le interfacce.
Variabili:
Una variabile è una locazione della memoria referenziabile mediante un identificatore; essa è caratterizzata
dal nome e dal tipo.
Dichiarazione: tipo nomeVariabile;
es.: int x; float a,b;
Nota: per i tipi riferimento avremo ad esempio: String nome; Persona p1, p2; (dove Persona è una classe).
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Operatore di assegnamento: =
Sintassi: nomeVariabile = espressione;
es.: int x, y; double a=2.5;
x=10; y = x+5;
x = a; // errore!
boolean cond; cond = true;
Casting:
L’operazione di conversione di tipo è chiamata casting e può essere implicita o esplicita.
Il casting implicito è lecito quando non comporta nessuna perdita di precisione:
int i=5;
double pi = 3.1456;
pi = i; // casting implicito lecito
i = pi; // casting implicito illegale, perdita di precisione
Nel casting esplicito dobbiamo specificare il tipo;
si può avere una perdita di precisione:
Operatori aritmetici:
Operatore
+
int i = 15;
double pi= 3.1456;
*
i = (int) pi;
// casting esplicito legale con perdita di precisione
/
pi = (double) i; // casting esplicito legale senza perdita di precisione
%
Operatori:
++
Gli operatori sono dei simboli speciali utilizzati per eseguire delle operazioni. --
Corso di Informatica 2
Azione
addizione
sottrazione
moltiplicazione
divisione
modulo, resto divisione intera
incremento
decremento
A.A 2015/16
Linguaggio Java
Alcuni operatoti aritmetici hanno delle forme compatte:
nome_variabile operatore= valore dove operatore può essere uno di [+,-,*,/,%]
Operatori Relazionali:
Operatori Logici:
Operatore
==
!=
>
>=
<
<=
Operatore
Azione
Utilizzo
&&
AND logico
x && y
||
OR logico
x || y
!
NOT Logico (unario)
!x
Azione
uguale
diverso
maggiore
maggiore uguale
minore
minore uguale
Operatore Condizionale
Questo operatore (?:) consente di specificare le espressioni condizionali;
! ++ -* / %
Sintassi: expr1 ? expr2 : expr3
+ -
Es.: a = ( b > c ) ? 0 : 5
> < >= <=
Nota: esistono altri operatori ( es. operatori sui bit ) che
per motivi di tempo non analizzeremo.
A fianco la tabella riepilogativa delle priorità degli operatori visti:
Corso di Informatica 2
== !=
&&
||
?:
= += -= *= /= %=
A.A 2015/16
Linguaggio Java
Blocco Sequenziale:
Anche in Java esiste il concetto di blocco; ovvero l’insieme di istruzioni racchiuse tra parentesi {…}, le quali vengono
eseguite in sequenza.
Strutture di controllo:
Sono strutture (istruzioni) che permettono di modificare il flusso di esecuzione di un programma.
Istruzioni Condizionali:
if :
if(condizione) istruzione;
Switch:
If-else: if(condizione)
istruzione1;
else
istruzione2;
if-else annidati: if(condizione1) istruzione1 ;
else if(condizione2) istruzione2;
else ……
Nota: la condizione va racchiusa tra parentesi;
Es.: if (a=b) …. // a differenza dello C in Java non è ammesso.
if (a==b) … // corretto.
Corso di Informatica 2
switch(espressione) {
case valore1:
istruzioni; break;
case valore2:
istruzioni; break;
……..
default:
istruzioni;
}
Nota: il valore dell’espressione deve essere
un intero, nelle ultime versioni di Java può
essere anche una stringa.
A.A 2015/16
Linguaggio Java
Istruzioni Iterative:
for:
for(inizializzazione; condizione; incremento) {
istruzioni;
}
Es.:
int i;
for(i=0;i<10;i++) System.out.println(i);
do-while:
while:
do {
istruzioni;
} while(condizione);
while(condizione) {
istruzioni;
}
Es.:
int i=0;
while(i<10){
System.out.println(i);
i++;
}
Es.: int n=10;
// non si dovrebbe entrare mai nel ciclo; ma n-- …
do {
n--;
System.out.println(n);
} while(n<10 && n>0);
Nota: break e continue hanno la stessa funzionalità vista in C.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Array:
Gli array (o vettori) indicano un insieme di elementi (componenti) tutti dello stesso tipo. Gli array in Java sono "oggetti"
che ereditano della classe Object, di cui possono richiamare tutti i metodi.
Dichiarazione: tipo [] nomeVettore;
Es.:
int [] x; // array di interi.
float [] a;
Il tipo vettore è un tipo riferimento; un riferimento ad un array si crea mediante l’operatore new:
Sintassi:
new tipo [dim];
Es.: x = new int [10]; a = new float [20];
for(i=0;i<10;i++) x[i]=i; // Caricamento valori.
Altro modo per creare un array, specificare i valori nella dichiarazione:
int [] x = {1,12,23,24,7,1,2,9,8,11}; // dove ad es. x[2] vale 23
char [] str = {'c','i','a','o'};
Accesso agli elementi di un array:
Es.:
nomeVettore[i]
// i-esima componente.
char c;
char [] str = {'c','i','a','o'};
c = str[2]; // c='a'
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Tutti gli array dispongono di una variabile istanza denominate length che ne indica la lunghezza:
Sintassi:
nomeVettore.length
Es.: int [] x = {1,-6,0,12,2};
System.out.println(x.length); // stampa 5
NB: In un array, i valori degl’indici vanno da 0 a length-1;
attenzione che l’indice non vada fuori range, altrimenti a differenza del linguaggio C il sistema da errore.
Nota: ciclo for potenziato per gli array (lettura) ;
es.: for(int valore : vettore_interi ) { istruzioni; }
Array Bidimensionali (matrici):
Dichiarazione:
Creazione:
Accesso elementi:
Es.:
tipo [][] nomeMatrice;
new tipo [dim1][dim2];
nomeMatrice[i][j]
// elemento della i-esima riga e j-esima colonna
int [][] m = new int [3][2]; m[0][0]=1; m[0][1]= -6; ….
oppure: int [][] m = { {1,-6}, {12,2}, {7,30} }
Stringhe:
Una stringa è una sequenza di caratteri alfanumerici; Java non presenta un tipo primitivo per le stringhe, ma esiste
una classe predefinita (String) che consente di trattare le stringhe.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Costruzione della stringa:
String s = new String("pippo"); // tramite costruttore
String t = "pippo"; // tramite assegnamento
Tale classe è dotata di numerosi metodi per la manipolazione delle stringhe; ad esempio:
- length() : ritorna la lunghezza (int) della stringa.
Es.: int lun = s.length(); // lun vale 5 .
- charAt(int i) : ritorna il carattere (char) nella posizione i-esima (il primo carattere occupa la posizione 0).
Es.: char c = s.charAt(2); // c vale 'p' .
- equals(String str): confronta la stringa con un’altra stringa str e ritorna un valore boolean
true se le stringhe sono uguali o false altrimenti.
Es.: boolean b = s.equals(t); // b vale true .
Nota: non utilizzare l’operatore di confronto == per verificare l’uguaglianza tra due stringhe
perché potrebbe dare risultati inaspettati.
- concat(String s): Concatena la stringa con la stringa s.
Es.: String s1 = "Ciao";
String s2 = "Mondo";
s1 = s1.concat(s2); // "CiaoMondo"
Nota: per concatenare due stringhe si può usare l’operatore: +
Es.: s1 = s1 + s2; // "CiaoMondo"
Nota: Per gli altri metodi della classe String, si rimanda alla documentazione Java.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Classi e Oggetti:
Un programma Java è un insieme di definizioni di classi. Una classe descrive una generica entità (prototipo),
mediante la definizione dei suoi attributi e dei suoi metodi.
Da ciascuna classe vengono fatte derivare una o più istanze, dette oggetti. Esse differiscono perché ogni istanza
conserva il proprio stato e i metodi invocati di una determinata istanza hanno effetto sullo stato di quella istanza.
Definizione di una classe:
modificatore class nomeClasse {
<corpo_della_classe>
}
Il <corpo_della_classe> è costituito dalla dichiarazione delle variabili (attributi della classe) e dalla definizioni di
metodi (comportamento della classe). Gli attributi sono variabili che permettono di modellare lo stato degli oggetti.
Definizione dei metodi:
modificatore tipo nomeMetodo (lista_parametri) {
<corpo_del_metodo>
}
modificatore: indica la visibilità o accessibilità del metodo (vedremo meglio più avanti).
tipo: indica il tipo del valore di ritorno del metodo.
nomeMetodo: è l’identificatore del metodo.
lista_parametri: elenco dei parametri di input del metodo.
corpo_del_metodo: indica la definizione del metodo vera e propria.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Esiste un metodo speciale, detto costruttore, che ha lo stesso nome della classe e che permette di creare oggetti
(istanze) della classe.
Sintassi:
nomeClasse nomeOggetto = new nomeClasse(lista_parametri);
Esempio di una classe:
public class Point {
double x,y; // Attributi
// Costruttore:
public Point(double val_x, double val_y) {
x= val_x;
y= val_y;
}
// Metodo:
public double distance(Point p) {
return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
}
}
Invocazione dei metodi:
Per invocare un metodo di un oggetto: nomeOggetto.nomeMetodo(lista_parametri);
Es.:
Point p1 = new Point(1.2, 2.5);
Point p2 = new Point (0, 2.6);
double d = p1.distance(p2);
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
public class Persona {
// Variabili (attributi)
private String nome;
private String cognome;
private int eta;
// Costruttore
public Persona(String n, String c, int e) {
nome = n;
cognome = c;
eta = e;
}
// Metodi
public void presentazione() {
public class TestPersona {
public static void main(String[] args) {
/* Creazione di un'istanza di Persona (oggetto)
* tramite costruttore */
Persona p = new Persona("Mario", "Rossi",28);
/* Invocazione di metodi */
p.presentazione();
// Nominativo: Mario Rossi età: 28 anni
p.invecchia(3);
p.presentazione();
// Nominativo: Mario Rossi età: 31 anni
}
}
System.out.println("Nominativo: " + nome + " " +
cognome + " età: " + eta + " anni");
}
public void invecchia(int nAnni) {
eta += nAnni;
}
}
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
main:
Il metodo main rappresenta il metodo principale di un programma Java, dal quale ha inizio l’esecuzione
dell’applicazione. Un programma Java è costituito da un insieme di classi, pertanto deve esistere una classe, che
implementi il metodo main; (di tipo static, cioè un metodo che può essere invocato anche in assenza di istanze).
Sintassi:
public static void main(String[] args) { ….. }
E’ un metodo pubblico (public), non ha valore di ritorno e args rappresenta un array di stringhe contenente gli
argomenti passati da linea di comando.
Package - Libreria Java:
In Java un package (pacchetto) indica una raccolta di classi correlate. Esso può contenere al suo interno sia classi sia
altri package, secondo una struttura gerarchica.
Java possiede una vastissima libreria di classi standard organizzata in vari package, che raccolgono le classi secondo
un’organizzazione basata sul campo d’utilizzo.
Il package java è il package che contiene tutti gli altri. Al suo interno ve ne sono altri, come ad esempio lang, io, awt
ecc.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
I principali package sono:
java.io : contiene classi per realizzare l’input/output.
java.awt : contiene classi per realizzare interfacce grafiche.
java.net : contiene classi per realizzare connessioni, come Socket, URL, ecc.
java.applet : contiene un’unica classe Applet che permette di realizzare le applets.
java.util : raccoglie classi d’utilità, come ad esempio Date.
java.lang : è il package che contiene le classi nucleo del linguaggio, come System, String, ecc.
(In ogni programma Java, questo package è importato automaticamente.)
Per utilizzare una classe della libreria, bisogna prima importarla. Supponiamo di voler utilizzare la classe Date del
package java.util. Prima di dichiarare la classe in cui abbiamo intenzione di utilizzare Date dobbiamo scrivere:
import java.util.Date;
oppure, per importare tutte le classi del package java.util:
import java.util.*;
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Modificatori (specificatori) di accesso:
I modificatori di accesso permettono di specificare la visibilità di una classe, di un metodo e di un attributo.
public: l’accesso ad una "caratteristica" public è consentito a tutte le altre classi. Può essere utilizzato sia per classi,
per metodi che per attributi.
private: l’accesso è consentito solo agli elementi della classe stessa. Può essere usato solo per metodi e attributi.
protected: l’accesso è consentito a tutte le classi nello stesso pacchetto e a tutte le sottoclassi. Può essere applicato
solo a metodi e attributi.
default: si ha quando non si specifica nessun modificatore di accesso. Con accesso di default si intende che
l’accesso è consentito solo alle classi nello stesso pacchetto.
// Esempio per public e private:
public class MyClass {
public int var1;
private int var2;
public void metodoA() {
//… istruzioni …
}
private void metodoB() {
//… istruzioni …
}
}
public class TestMyClass {
public static void main(String[] args) {
MyClass a = new MyClass();
a.var1 = 10;
a.var2 = 10; // non consentito !
a.metodoA();
a.metodoB(); // non consentito !
}
}
Nota: metodoB() può essere invocato all’interno di metodoA().
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Modificatore static:
Variabili static:
se una variabile di una classe ha il modificatore static essa è unica per tutte le istanze della classe (variabile di classe).
public class MyClass {
public static int i = 10;
public int j = 10;
public void incrementa() {
i++;
j++;
}
}
public class TestMyClass {
public static void main(String[] args) {
MyClass a = new MyClass();
MyClass b = new MyClass();
a.incrementa(); // avremo che a.i = 11 e a.j = 11
b.incrementa(); // avremo che b.i = 12 e b.j = 11 (anche a.i = 12)
// poiché a.i e b.i sono la stessa variabile: MyClass.i
}
}
Metodi static:
Se dichiariamo un metodo static potremo evitare di istanziare la classe che lo contiene e richiamare il metodo statico
con la sintassi: nomeClasse.nomeMetodo(). Es.: Math.max(3, 5);
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
public class ContoCorrente {
private String nome;
private String cognome;
private long numConto;
private double saldoAttuale;
private static long prossimoNumConto = 1;
public ContoCorrente(String n, String c, double saldoIniz) {
nome = n;
cognome = c;
numConto = prossimoNumConto;
saldoAttuale = saldoIniz;
prossimoNumConto++;
}
public void deposito(double importo) {
saldoAttuale += importo;
}
public void prelievo(double importo) {
saldoAttuale -= importo;
}
public void stampaSaldo() {
System.out.println("Signor " + cognome + " " + nome
+ " titolare del c/c n. " + numConto
+ " con saldo pari a " + saldoAttuale);
}
}
public class TestContoCorrente {
public static void main(String[] args) {
ContoCorrente cc1;
cc1 = new ContoCorrente("Mario", "Rossi", 3000);
ContoCorrente cc2;
cc2 = new ContoCorrente("Fabio", "Verdi", 12000);
cc1.stampaSaldo();
cc2.stampaSaldo();
cc1.prelievo(500);
cc2.deposito(1000);
cc1.stampaSaldo();
cc2.stampaSaldo();
}
}
Nota:
In genere gli attributi si definiscono private (nascosti);
si accede ad essi attraverso i metodi dichiarati public
o comunque invocabili dall’esterno.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Derivazione di classi (Ereditarietà):
L'ereditarietà permette di creare nuove classi sulla base di classi esistenti. Questo favorisce il riutilizzo del codice
esistente. A partire da una classe A è possibile derivare una nuova classe B.
Sintassi:
class B extends A {
// Corpo della classe B
}
La classe A: classe padre o superclasse (classe base).
La classe B: classe figlio o sottoclasse (classe derivata).
La sottoclasse B:
•
•
•
•
eredita tutti i membri della superclasse;
può aggiungere nuovi membri;
può ridefinire i metodi della superclasse;
non può accedere ai membri privati della superclasse.
Nota: Il riferimento super viene usato per riferirsi alla superclasse.
È possibile definire il metodo costruttore della classe derivata, a partire dal costruttore della superclasse utilizzando
il costrutto:
super(lista_parametri);
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Es.: a partire dalla classe "Persona" definita in precedenza, deriviamo la classe "Studente" :
public class Studente extends Persona {
private int matricola;
// costruttore della sottoclasse Studente
public Studente(String n, String c, int e, int m) {
// si richiama il costruttore della superclasse Persona mediante il riferimento super
super(n,c,e);
matricola=m;
}
public void presentaStudente() {
presentazione(); // metodo della superclasse
System.out.println("Sono uno studente, numero di matricola: "+matricola);
}
public void modificaMatricola(int matr) {
matricola=matr;
}
}
Esercizio1: organizzare una classe di test per la classe Studente.
Esercizio2: provare a derivare la classe "Lavoratore"; (attributi: ditta, stipendio, anzianità_servizio, ecc.; metodi: … )
Nota:
Tutte le classi discendono dalla classe Object.
Se una classe non eredita esplicitamente da una superclasse, allora eredita implicitamente dalla classe Object.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Riferimento this:
La parola chiave this, utilizzata all’interno di un metodo (o costruttore),
fornisce un riferimento all’oggetto a cui il metodo è legato quando
viene richiamato.
public class MyClass {
private int var;
public void myMethod(int var) {
this.var = var ;
}
}
Aspetti del Polimorfismo:
Overloading (sovraccarico):
Nell’ambito del polimorfismo abbiamo l’overloading dei metodi; ovvero la possibilità di definire più metodi con lo
stesso nome variando i parametri d’ingresso. In fase di esecuzione verrà eseguito il metodo corrispondente in base ai
parametri coinvolti.
public class MyFunc {
public int somma(int x, int y) {
return x+y;
}
public float somma(float x, float y) {
return x+y;
}
public double somma(double x, double y ){
return x+y;
}
}
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Overriding (riscrittura):
Meccanismo che permette di ridefinire nella sottoclasse l’implementazione di metodi definiti nella superclasse.
Il metodo re-implementato (sovrascritto) deve avere la stessa "firma" (prototipo) del metodo della classe padre.
Esempio:
public class Prova {
// attributi …
private int x=5;
public void stampa(int y) {
System.out.println("Prova: " + (x+y));
}
}
public class Prova2 extends Prova {
// attributi …
public void stampa(int y) {
y++;
System.out.println("Prova2: " + y));
}
}
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Esempio riepilogativo:
public class Persona{
private String nome;
private String cognome;
private int eta;
public Persona() {
nome="Sconosciuto";
cognome="Sconosciuto";
eta = 0;
}
public Persona(String nome, String cognome, int eta) {
this.nome=nome;
this.cognome=cognome;
this.eta = eta;
}
public void presentazione() {
System.out.println("Nominativo: " + nome +
" " + cognome + " età: " + eta + " anni");
}
public void invecchia(int nAnni) {
eta += nAnni;
}
}
class Studente extends Persona{
private int matricola;
public Studente(int matricola){
super();
this.matricola=matricola;
}
public Studente(String nome, String cognome,
int eta, int matricola) {
super(nome, cognome, eta);
this.matricola=matricola;
}
public void presentaStudente() {
super.presentazione();
presentazione(); // this.presentazione();
}
public void presentazione(){
System.out.println("Sono uno studente, " +
"numero di matricola: " + matricola);
}
public void modificaMatricola(int matr) {
matricola=matr;
}
}
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Modificatore final:
Questo modificatore è applicabile alle variabili ai metodi e alle classi:
• Una variabile dichiarata final diviene una costante ( es.: final int dayInWeek = 7; ).
• Un metodo dichiarato final non può essere riscritto in una sottoclasse (non è possibile applicare l’overriding).
• Una classe dichiarata final non può essere estesa (non può avere sottoclassi).
Metodi - passaggio di parametri:
In Java il passaggio dei parametri avviene solo per valore. Quindi nessuna modifica nel metodo sui parametri formali
cambierà i valori dei parametri attuali passati come argomenti.
Il passaggio per riferimento si ha implicitamente quando si hanno parametri formali di tipo array o oggetti; in questo
caso viene passato il riferimento, quindi implicitamente l’indirizzo di memoria dell’oggetto. Ciò implica che le eventuali
modifiche verranno effettuate direttamente sull’oggetto interessato.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Input/Output:
Come in C e C++ l’input/output è supportato da una libreria e non dal linguaggio. La libreria si chiama java.io .
L’ I/O è gestito mediante flussi (stream) di dati che permettono di collegare un’applicazione con i dispositivi di I/O.
System.out : rappresenta lo standard output (tipicamente il monitor). È dotato dei metodi print e println
che permettono di stampare informazioni a video.
System.in : rappresenta lo standard input (tipicamente la tastiera). Permette di gestire un flusso di byte in input.
System.err : messaggi di errore a video.
Esempi di scrittura:
System.out.print("Hello World ! ");
System.out.println("Hello World ! ");
int var1 = 10;
System.out.print("Valore della variabile: "+var1);
Nota: per le operazioni di lettura (input), siccome System.in, lavora a livello di byte, si ricorre ad altre classi:
InputStreamReader : permette di convertire un flusso in input di byte in un flusso in input di caratteri;
BufferedReader : permette di prelevare/leggere da un flusso di caratteri in input una stringa di caratteri o un
singolo carattere attraverso i metodi readline() e read() rispettivamente.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Esempi; Input di una stringa:
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String str;
System.out.print("Inserire la stringa: ");
str= br.readLine();
System.out.print("Stringa inserita: "+str);
Input di un intero:
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int i;
System.out.print("Inserire un intero: ");
i= Integer.parseInt(br.readLine());
System.out.print("Intero inserito: "+i);
Per la lettura si può usare anche la classe Scanner; esempio input di un double:
import java.util.*;
……..
Scanner console = new Scanner(System.in);
System.out.println("Inserire un numero: ");
double number = console.nextDouble();
System.out.println("Numero inserito: " +number);
// console.close();
Nota: Per maggiori dettagli riguardo le operazioni di I/O si rimanda alla documentazione di Java.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Nuovo metodo da aggiungere alla classe Persona vista in precedenza; (importare java.io.*):
public void modificaDati() {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String n="", c=""; int e=0;
try {
System.out.print("Inserire il nome: ");
n= br.readLine();
System.out.print("Inserire il cognome: ");
c= br.readLine();
System.out.print("Inserire l'età: ");
e= Integer.parseInt(br.readLine());
}
catch (IOException err) {
System.out.println("Errore in input !");
System.exit(-1);
}
Test di verifica:
catch (NumberFormatException err) {
System.out.println("Errore di formato nel valore inserito !");
…...
System.exit(-1);
Persona pers = new Persona();
}
pers.modificaDati;
nome = n;
pers.presentazione;
cognome = c;
……
eta = e;
}
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Classe Math
La classe Math si trova all’interno del package java.lang e definisce costanti matematiche e metodi per le più comuni
funzioni matematiche. Ad esempio:
Costanti:
public static final double E ( 2.718281828459045 )
public static final double PI ( 3.141592653589793 )
uso: double r = 5; // raggio
double c = 2 * Math.PI * r;
Metodi:
public static double abs(double x)
public static double log(double x)
public static double sqrt(double x)
public static double min(double x, double y)
public static double max(double x, double y)
public static double random()
...
Tutti i metodi sono static, cioè sono associati alla classe e non alle singole istanze.
Es.: double x = Math.sqrt(3.455);
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Esempio:
// Creazione di una finestra grafica a video.
import java.awt.*;
public class Finestra extends Frame {
public Finestra(String titolo) {
super(titolo);
setLocation(100,100);
setSize(400,100);
setVisible(true);
// show(); deprecated !
System.out.println("Creazione finestra.");
}
public static void main(String[] arg) {
new Finestra("Finestra Vuota");
System.out.println("Ho creato la finestra !");
}
}
Nota: Le interfacce grafiche o GUI (Graphical User Interface), permettono la creazione di applicazioni flessibili e più
semplici da usare; mettendo a disposizione strumenti grafici come finestre, menu, bottoni, ecc.
In Java esistono due package che permettono di creare interfacce grafiche: java.awt e javax.swing .
La programmazione è di tipo “event-driven” ovvero guidata dagli eventi. Un programma con interfaccia grafica si
mette in attesa che l’utente interagisca con il computer. Ad ogni azione si genera un evento; esistono degli appositi
“oggetti” che si occupano della gestione degli eventi.
Un oggetto di questo tipo è detto listener (ascoltatore), ed implementa un’interfaccia opportuna dipendente dal
tipo di evento da trattare. Ad esempio: ActionListener, MouseListener, WindowListener, ecc.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Interfaccia:
Un’interfaccia è una collezione di definizioni di metodi privi di implementazione. In altre parole, è simile ad una classe,
ma può contenere solo variabili statiche e metodi astratti.
Pertanto una classe che implementa una interfaccia, deve implementare tutti i metodi che quest’ultima prevede.
// Creazione di una finestra a video, con gestione delle interazioni.
import java.awt.*;
import java.awt.event.*;
public class FinestraOk extends Frame {
public FinestraOk(String titolo) {
super(titolo);
setLocation(100,100);
setSize(400,100);
setVisible(true);
addWindowListener(new FinestraWindowListener());
}
public static void main(String[] arg) {
new FinestraOk("Finestra Vuota");
System.out.println("Ho creato la finestra");
}
// continua ….
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
class FinestraWindowListener implements WindowListener {
public void windowActivated(WindowEvent e) {
System.out.println("Sentito un Window Activated");
}
public void windowClosed(WindowEvent e) {
System.out.println("Sentito un Window Closed");
}
public void windowClosing(WindowEvent e) {
System.out.println("Sentito un Window Closing");
System.exit(0);
}
public void windowDeactivated(WindowEvent e) {
System.out.println("Sentito un Window Deactivaded");
}
public void windowDeiconified(WindowEvent e) {
System.out.println("Sentito un Window Deiconified");
}
public void windowIconified(WindowEvent e) {
System.out.println("Sentito un Window Iconified");
}
public void windowOpened(WindowEvent e) {
System.out.println("Sentito un Window Opened");
}
}
}
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Applet:
La diffusione (o successo) di Java è dovuta in buona parte alle applets.
Un’applet è una "piccola applicazione" java integrata in una pagina web. Quando il browser accede ad una pagina
contenente un’applet, quest’ultima viene eseguita mediante la JVM incorporata nel browser stesso. Esempio:
import java.applet.Applet;
import java.awt.Graphics;
public class HelloApplet extends Applet {
public void paint(Graphics g) {
g.drawString("Hello world!", 50, 25);
}
}
<HTML>
<HEAD>
<TITLE> A Simple Program </TITLE>
</HEAD>
<BODY>
Here is the output of my program:
<APPLET CODE="HelloApplet.class" WIDTH=150 HEIGHT=25>
</APPLET>
</BODY>
</HTML>
Nota: deriva dalla classe java.applet.Applet e non presenta il metodo main (tipico delle applicazioni).
Il metodo paint(), ereditato dalla superclasse Container, viene chiamato implicitamente dal browser quando è
necessario (ri)disegnare l’applet.
Nel riquadro di destra è riportato un esempio di file html, per eseguire l’applet mediante browser.
In alternativa, per eseguire un’applet, si può usare AppletViewer; programma nato per testare le applet.
Corso di Informatica 2
A.A 2015/16
Linguaggio Java
Metodi che regolano il ciclo di vita di un’applet:
- init(): invocato al momento dell'apertura della pagina che contiene l‘applet.
- stop(): invocato nel momento in cui l’applet viene sospeso;
(Es.: quando la pagina Web che la contiene viene iconizzata nel Browser)
- start(): invocato nel momento in cui l‘applet viene ripristinato.
- destroy(): invocato nel momento in cui la pagina Web che contiene l‘applet viene chiusa.
- paint(Graphics g): invocato ogni volta che l’applet deve essere ridisegnata;
Il metodo paint permette di disegnare degli oggetti grafici nella finestra del browser. Prende in input
come parametro un oggetto della classe Graphics, rappresentante l'area grafica dell'applet.
La classe Graphics definisce un discreto numero di metodi per la visualizzazione di forme geometriche,
text, ecc; ad esempio:
drawLine(int x1, int y1, int x2, int y2)
drawRect(int x, int y, int width, int height)
drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)
drawPolygon(int[] x, int[] y, int n)
drawString(String str, int x, int y)
…..
Corso di Informatica 2
A.A 2015/16