La programmazione

ad oggetti in Java
Introduzione allo sviluppo orientato ad
oggetti

Materiale realizzato nell’ambito del corso di

Programmazione ad Oggetti tenuto dal professor
Mario Vento, CDL di Ingegneria Informatica, anno
accademico 2007/2008, Università degli Studi di
Salerno.

Vincenzo De Notaris
8/1/2008
 LA PROGRAMMAZIONE AD OGGETTI IN JAVA

Paradigma ad oggetti

Ogni linguaggio di programmazione fornisce delle astrazioni. La complessità di tale

linguaggio ha una correlazione diretta all’astrazione con la quale si va ad operare.

I linguaggi di programmazione di basso livello rappresentano un’astrazione della

macchina in oggetto. Il programmatore è tenuto a stabilire la relazione che intercorre
tra il modello del calcolatore ed il modello del problema che si intende risolvere.

L’approccio orientato ad oggetti (Object Oriented Programmation) rappresenta

un’evoluzione importante dei concetti sopra detti, dando possibilità al programmatore
di rappresentare elementi dello spazio dei problemi stessi, senza quindi l’obbligo di
rifarsi alla peculiarità inside della specifica macchina. Il modello di sviluppo orientato
ad oggetti rappresenta, quindi, uno strumento potente e completo nell’ambito
dell’ingegneria del software.

L’oggetto

L’oggetto è l’unità fondamentale del modello, un entità a se stante tramite il quale è

possibile memorizzare dati. Gli attributi sono le qualità che volgiamo rappresentare nei
nostri oggetti, e per i nostri scopi possono essere considerati come i dati posseduti
dall’oggetto e che esso ha la responsabilità di gestire garantendone la consistenza.
L’insieme degli attributi di un oggetto è spesso identificato come lo stato dell’oggetto.
E’ interessante notare come nell’OOP un oggetto possa esser costituito da altri oggetti
(od anche tipi primitivi); data tale caratteristica è facile evincere come un programma
altro non sia che un insieme di oggetti che tra loro interagiscono.

Ciascun oggetto è un istanza di una classe, ove classe assume un significato

perfettamente comparabile a quelli di tipo; è possibile, quindi, affermate che ogni
oggetto è associato un tipo.
La keyword per istanziare un oggetto è new, seguendo le specifiche dettate
dall’implementazione costruttore. Nell’esempio sottostante, poiché non riceve
parametri, il costruttore è detto di default.

// istanza di un oggetto di tipo Console denominato nextGen

Console nextGen = new Console();

Ad un oggetto è possibile effettuare richieste, ossia chiedere di fruire un servizio. Le

operazioni che esso è in grado di compiere sono definite tramite la sua interfaccia, che
stabilisce quali richieste è possibile rivolgere ad un determinato oggetto. L’invocazione
di un metodo sull’oggetto prende la definizione di messaggio.

Tra oggetti diversi sussistono delle relazioni, catalogate in diversi tipi: strutturali, non
strutturali, di ereditarietà, di realizzazione, di associazione e di composizione.

L’information hiding

Una delle caratteristiche più importanti dell’OOP è l’information hiding, che permette
di creare una netta separazione tra colui che utilizza oggetti e colui che li definisce
attraverso delle regole di visibilità associate ad attributi e metodi di una classe. In Java
vengono utilizzate tre keyword per esplicitare tali regole. La parola chiave public
stabilisce che le definizioni che seguono sono disponibili a tutti, private che esse siano
visibili sono all’interno della classe, protected che esse non siano visibili all’esterno, ma
accessibili alle classi derivate (concetto che verrà chiarito in seguito).

public class Console{

// costruttore
public console(){
// inizializza gli attributi
}

// attributi
public int giocatori;
protected Joypad controller = new Joypad();
private Chip piastra = new Chip();

// metodi
public void setGiocatori(int giocatori){
this.giocatori = giocatori;
}

public void setJoypad (Joypad controller){

this.controller = controller;
}

public void setChip (Chip piastra){

this.piastra = piastra;
}

Progettare e programmare in questo modo rende possibile a tutte le altre parti del
sistema, cioè agli altri oggetti che collaborano ed utilizzano i servizi come dei client,
di ignorare il meccanismo interno di implementazione, permettendo, tra le altre cose,
di realizzare con maggiore libertà i servizi. Quest’approccio aumenta la modularità,
diminuisce l’accoppiamento tra le parti del sistema e promuove il riutilizzo del
software in contesti diversi da quello in cui è stato inizialmente progettato.

Come visto finora è possibile raggruppare gli oggetti del nostro dominio del problema
in classi.

Si è accennato al fatto che una classe è un utile meccanismo di astrazione, che, come
tale, ci permette di gestire la complessità del problema trascurando i particolari
accessori degli oggetti e rappresentando solo le caratteristiche importanti per la
nostra applicazione.

Una classe, quindi, non è corretta in sé, come un’astrazione non è corretta in sé, ma
solo in relazione al contesto in cui la facciamo: la domanda che ciò conduce nel
processo di astrazione è quali sono i comportamenti e gli attributi che regolano
l’andamento del sistema che vogliamo progettare e quali invece sono del tutto
accessori. Quindi una classe è un ‘insieme di comportamenti e attributi comuni ad un
insieme di oggetti del nostro sistema, che rappresentino una responsabilità univoca
(semantica comune).
I package

I package del linguaggio Java costituiscono uno strumento di raggruppamento di

classi, cosa che ci consente di scomporre una qualsiasi applicazione in maniera
modulare.
Un package, come da definizione, può contenere un numero qualunque di classi od
anche di altri package, quest’ultima operazione tramite la keyword import.

L’impiego dei package risulta essere uno strumento assai utile in quanto consente di
decomporre il problema in sottoproblemi, che possono essere assegnati ad un package
o ad insiemi di package. Le classi contenute nel package decomporranno e
risolveranno il sottoproblema seguendo l’approccio divide et impera.

E possibile con essi gestire lo sviluppo parallelo del codice, poiché package diversi
possono essere assegnati a diversi team di sviluppo, favorendo il rispetto dei tempi di
consegna, tracciare le dipendenze tra diversi moduli, realizzati con i package; in
questo modo è possibile tenere sotto controllo l’accoppiamento dell’applicazione.

Il meccanismo dei package consente anche di evitare conflitti sui nomi delle classi
quando queste vengono caricate da web. In questo caso, è possibile che esitano classi
con lo stesso nome residenti su siti differenti, e che , nel corso dell’esecuzione del
programma, vengano riferite. Il meccanismo dei package si dimostra quindi
insostituibile per evitare pericolose ambiguità: a ciascuna classe corrisponderà uno
spazio dei nomi differente, cui potremo riferirsi senza possibilità di errore.

Il meccanismo dei package fa parte integrante del linguaggio, anche quando non
vengono esplicitamente creati, infatti, compilando una classe, questa farà parte del
cosiddetto “package di default”, che corrisponde alla directory in cui risiede il .class.

Con i package è possibile organizzare anche le librerie Java, ovvero le API. Le classi
fondamentali per ogni programma sono nel package java.lang, l’unico ad essere
visibile automaticamente.

Le regole per la denominazione di package è similare a quella utilizzata per i domini

internet.
A punti consecutivi corrispondono directory annidate.

Poiché i package sono un meccanismo di aggregazione delle classi, una delle

caratteristiche fondamentali legate ad essi è la visibilità reciproca che hanno le classi
appartenenti allo stesso package ed a package diversi. Se una classe è definita public
in un package, classi esterne al package possono riferirla ed importarla, laddove al
contrario, se una classe ha visibilità di default, ovvero non è stata dichiarata public
essa sarà visibile solo alle classi appartenenti al suo stesso package. Questo promuove
la coesione delle classi all’interno di un package, che dovrebbero concorrere
strettamente a implementare le funzionalità assegnategli, che invece possono essere
accedute attraverso le sue classi pubbliche. Come si può vedere questo è un altro
meccanismo che assicura l’information hiding nei nostri programmi.
I modificatori

Java mette a disposizione una serie di modificatori che consentono di variare il

comportamento e la visibilità di variabili e metodi appartenenti ad una classe.

I modificatori di accesso sono public, protected, private.

Di questi è stato spiegato il significato in precedenza. C’è da aggiungere che i metodi
protetti sono visibili anche alle classi dello stesso package, oltre a quelle derivate.

Il modificatore static è usato per metodi e variabili di classe, ovvero variabili non
legate ad alcuna istanza ma direttamente alla classe in cui sono dichiarate.
Una variabile static è condivisa tra tutti gli oggetti istanza della stessa classe.
In particolare è possibile rappresentare i campi static come appartenenti ad un’area di
memoria comune a tutte le classi, mentre l’area di memoria delle variabili e d’istanza
viene copiata e ripetuta per ciascuna istanza della classe. Poiché è possibile creare
anche variabili reference di tipo static, ovvero variabili che puntino ad oggetti e
statiche, in Java esistono dei costrutti detti inizializzatori statici. Si tratta di una coppia
di parentesi, che si possono scrivere in qualunque punto all’interno di una classe,
precedute dal modificatore static, che viene eseguita non appena la classe viene
referenziata la prima volta, e prima di ogni suo costruttore. È possibile inserire quanti
blocchi stati si vuole, questi vengono eseguiti nell’ordine in cui appaiono nella classe
dall’alto verso il basso.
I problemi legati alla condivisione del valore delle variabili statiche divengono molto
forti nel caso di programmi concorrenti. In questo caso, è necessario utilizzare le
tecniche di sincronizzazione di accesso alle variabili della classe.
I metodi dichiarati statici sono anche detti metodi di classe. I metodi pubblici dichiarati
statici possono essere richiamati indipendentemente dall’esistenza di un istanza della
classe. I metodi che operano su uno specifico oggetto non devono essere dichiarati
static, mentre quelli che sono di utilità generale e che non agiscono sulle singole

istanze, devono essere dichiarati static. I metodi statici non possono accedere alle
variabili della classe che non sono dichiarate anch’esse statiche.

Il modificatore abstract è utilizzato per creare metodi e classi astratte. Questo concetto
verrà chiarito in seguito.

Il modificatore final viene utilizzato per classi, metodi e variabili, ed ha la

caratteristica di vietare ogni modifica sulla classe, metodo o attributo cui è applicato.
Il suo scopo è rendere immodificabile un campo, ossia semplicemente renderlo
costante.
Ci sono due motivi per dichiarare una classe final: vietare ad altri di creare sottoclassi
ed aumentare l’efficienza (in quanto il compilatore sa che non possono esserci delle
sottoclassi che ridefiniscono i metodi di una classe final). Il modificatore final ha un
comportamento diverso se applicato a variabili di tipo primitivo. Per i tipi primitivi, la
variabile diviene una costante il cui valore deve essere noto in compilazione. Essendo
una costante esso non potrà essere più modificato. Quando il modificatore final è
utilizzato per un riferimento a un oggetto, allora: al momento della dichiarazione, al
riferimento deve essere assegnato un oggetto; il riferimento non potrà in seguito
riferirsi a un altro oggetto. È però possibile modificare l’oggetto riferito.

Il modificatore syncronized serve a sincronizzare attributi o metodi. Verrà chiarito il suo

utilizzo approfondendo la concorrenza (programmazione multi-thread).

Le possibilità offerte dalle librerie di Java sono molte , ma non infinite: possono
esistere casi in cui si vuole accedere a codice già scritto o a dispositivi fisici attraverso
un’applicazione scritta in Java.
In questi casi è possibile usare il meccanismo dei metodi native (ovvero nativi) scritti in
C e C++.

L’ereditarietà

Il riuso del codice implementato per strutturare un oggetto è uno dei maggiori
vantaggi offerto dai linguaggi di programmazione ad oggetti. In tale contesto trova
perfetta collocazione il concetto di ereditarietà, uno dei meccanismi di
rappresentazione ed astrazione più potenti dei linguaggi object oriented. In
particolare, permette di generalizzare ed astrarre, rappresentando in una sola classe
(detta superclasse) attributi e metodi comuni a più classi (dette sottoclassi o classi
derivate). Quando si eredita da un tipo esistente, ne vien creato uno nuovo contenente
non soltanto gli elementi del tipo esistente (sebbene quelli private siano inaccessibili e
nascosti), ma anche la duplicazione dell’interfaccia della classe. Avendo superclasse e
classe derivata la stessa interfaccia, per differenziare le due vengono utilizzati due
procedimenti: aggiungere metodi alla classe derivata o ridefinirne l’implementazione.

public class Console{

// costruttori, attributi e metodi della classe Console
}

Si può osservare come l’ereditarietà avviene tramite la parola chiave extends.

public class Nintendo extends Console{

// costruttori, attributi e metodi della classe derivata Nintendo
}

public class Microsoft extends Console{

// costruttori, attributi e metodi della classe derivata Microsoft
}
 public class Sony extends Console{
// costruttori, attributi e metodi della classe derivata Sony
}

E’ opportuno notare come Java una classe può ereditare al massimo da una sola
classe.
Il polimorfismo

Un elemento fondamentale della programmazione ad oggetti è il polimorfismo.

Letteralmente, la parola polimorfismo indica la possibilità per uno stesso oggetto di
assumere più forme, rendendoli di fatto intercambiabili. Esso indica l'attitudine di un
oggetto a mostrare più implementazioni per una singola funzionalità.

Tale comportamento è possibile grazie all’utilizzo del late binding (collegamento

dinamico) che evita chiamate assolute per il codice da eseguire, calcolando l’indirizzo
del corpo del metodo utilizzando informazioni immagazzinate nell’oggetto in causa. Di
conseguenza ciascun oggetto può comportarsi diversamente a seconda del contenuto
di una particolare porzione del sorgente.

Per rendere l’idea del concetto è utile vedere il codice, rifacendoci alle classi sopra
descritte.
Il metodo gioca utilizza come parametro un oggetto c di tipo Console.

public void gioca(Console c){

c.avviaDisco;
C.caricaMissione;
c.avviaMissione;
}

Con il polimorfismo possiamo utilizzare questo metodo per classi derivate diverse tra
loro senza implementazioni aggiuntive.

Console wii = new Nintendo();

Console xbox360 = new Microsoft();
Console ps3 = new Sony();

gioca(wii);
gioca(xbox360);
gioca(ps3);

Il metodo visto di trattare un tipo derivate come se fosse un tipo base è detto
upcasting (conversione di tipo verso l’alto).

Uno dei maggiori benefici del polimorfismo, come in effetti di un po' tutti gli altri
principi della programmazione ad oggetti, è la facilità di manutenzione del codice.
Classi e metodi astratti

Durante la programmazione è possibile incomba la necessità di utilizzare una classe

base dotata di sola interfaccia per le classi ad esse derivate, in modo che sia
impossibile creare un oggetto della superclasse in questione. Questo risultato si
ottiene attraverso la definizione di una classe astratta tramite la keyword abstract. Non
è possibile creare oggetti della classe astratta. Il meccanismo in questione è
funzionale anche per i metodi, in modo da posticipare l’implementazione nella classe
derivata stessa, ammesso e non concesso che essa realmente abbia significato in quel
punto della gerarchia.

Qui di seguito viene implementata in maniera differente la classe Console utilizza

precedentemente come esempio.

public abstract class Console{

public abstract void configura();

Il corpo del metodo configura vien rimandato alle classi derivate e può essere scritto in
maniera differente l’un dall’altro.

public class Nintendo extends Console{

public void configura(){

// configurazione specifica dell’oggetto Nintendo
}

public class Microsoft extends Console{

public void configura(){

// configurazione specifica dell’oggetto Microsoft
}

public class Sony extends Console{

 public void configura(){
// configurazione specifica dell’oggetto Sony
}

I metodi astratti sono utilizzabili solo se all’interno di classi astratte.

Le interfacce

In Java non esiste come in altri linguaggi (ad esempio il C++) il concetto di ereditarietà
multipla secondo il quale una classe può essere una estensione di più superclassi: una
classe può essere la specializzazione di una sola classe. Questo rende il linguaggio più
semplice da usare, ma più restrittivo nella implementazioni di modelli che utilizzano
l’ereditarietà multipla.

Java risolve il problema con l’introduzione delle interfacce.

Un’interfaccia è una collezione di definizioni di metodi privi di implementazione, che
non possono contenere dichiarazioni di variabili istanza (variabili istanza: variabili
proprie di ogni oggetto e non comuni a tutti gli oggetti della classe); una qualunque
classe può implementare una o più interfacce.

Le interfacce non fanno parte della gerarchia delle normali classi: al vertice della
gerarchia delle interfacce non c’è la classe Object.

Per dichiarare una nuova interfaccia si usa la parola chiave interface.

public interface InizializzaConsole {

public static final int maxGiocatori = 4;

public abstract void configura();
void aggiorna();

I metodi possono essere dichiarati public e abstract e non possono essere protected o
private.

La parola chiave abstract è un rafforzativo perché i metodi delle interfacce sono

sempre astratti, anche se si omette la parola chiave.

Se non si specificano i modificatori come nel caso di aggiorna(), il metodo acquista la

stessa visibilità della classe (in questo caso public).

Un iterfaccia può essere definita come estensione di un’altra interfaccia tramite la

parola chiave extends.

public interface InizializzaConsole extends AltraInterfaccia {

public static final int maxGiocatori = 4;

public abstract void configura();
void aggiorna();
 }

La gerarchia delle interfacce gode dell’ereditarietà multipla.

public interface InizializzaConsole extends AltraInterfaccia1,

AltraInterfaccia2, AltraInterfaccia3 {

public static final int maxGiocatori = 4;

public abstract void configura();
void aggiorna();

InizializzaConsole contiene tutte le definizioni di metodi e di costanti delle altre tre

interfacce che estende.

Con la parola chiave implements una classe si impegna a implementare i metodi definiti
nell’interfaccia.
Se una classe implementa un’interfaccia le sue sottoclassi ne ereditano i metodi.
Una classe può implementare un numero qualsiasi di interfacce.

public class Nintendo extends Console implements InizializzAConsole{

// costruttori, attributi e metodi della classe Nintendo
}

Se due interfacce hanno lo stesso metodo con lo stesso profilo basta implementarne
uno.
Se i metodi con lo stesso nome hanno diverso profilo vanno implementati entrambi.
Se i metodi con lo stesso nome hanno lo stesso profilo, ma restituiscono tipi diversi il
compilatore segnala un errore.

È possibile utilizzare le interfacce per dichiarare istanze di classi; in altre parole è

possibile dichiarare una variabile di tipo interfaccia e assegnarle istanze di classi che
implementano l’interfaccia.

InizializzaConsole init = new Nintendo();

Poiché init è un oggetto di tipo InizializzaConsole è possibile invocare su di esso i

metodi configura() ed aggiorna() descritti sopra.

Le interfacce possono anche essere utilizzate per raccogliere un insieme di costanti da

importare in varie classi
La gestione delle eccezioni

Con gestione delle eccezioni si suole intendere un meccanismo di gestione degli errori
integrando metodi di controllo direttamente nel linguaggio di programmazione; il Java
si rifà esattamente a questo modello.

Il programmatore definisce dei blocchi di codice (detti handler) per la gestione delle
eccezioni dei tipi interessati. Nel caso in cui venga rilevata una condizione anomala, il
metodo costruisce un ‘eccezione della classe che rappresenta e la “lancia”, per far sì
che i meccanismi preposti alla “cattura” possano gestirla.

Il lancio di un eccezione trasferisce il controllo dell’esecuzione all’handler attivo

specifico per quella data eccezione; nel caso in cui nessun handler venga trovato,
l’esecuzione del programma termina con un errore.

Il meccanismo delle eccezioni presenta considerevoli vantaggi: il programmatore è in

grado di decidere quali situazioni gestire ed in quale modo; le istruzioni delle eccezioni
sono separate da quelle che si occupano del flusso normale del programma, evitando
complessità di scrittura del sorgente; è possibile incorrere in un errore senza per forza
di cose terminare l’esecuzione del software.

In Java esiste è possibile verificare a tempo di compilazione che il programmatore,

tramite un messaggio a video, abbia gestito tutte le eccezioni appartenenti ad un dato
tipo, a meno che non abbia esplicitamente dichiarato di non voler occuparsi della
cosa. Le eccezioni che rientrano in questa specifica vengono denominate eccezioni
controllate (checked exceptions); esse sono determinate di tale specie nella classe
dell’eccezione stessa attraverso la keywork extends Exception.

public class EsempioException extends Exception {

// serial UID di default o generato, eventuale metodo di notifica
}

Un metodo che può lanciare un’eccezione controllata deve dichiararlo esplicitamente

nella sua intestazione e può essere richiamato solo all’interno del blocco di codice
associato ad un handler per quell’eccezione od all’interno di un altro metodo che
dichiara di poter lanciare quell’eccezione. Di conseguenza, quando viene scritto un
metodo contenente istruzioni in grado di lanciare un’eccezione controllata è costretto
a scegliere due alternative: inserire le istruzioni all’interno di un handler; dichiarare
che tal metodo può lanciare l’eccezione indi trasferire la responsabilità di gestione al
chiamante.
Nella definizione di un metodo le eccezioni controllate lanciabili vanno dichiarate dopo
l’elenco dei parametri tramite la keyword throws.
 public void metodoConEccezione(int parametroEsempio) throws
EsempioException {
// implementazione del metodo
}

EsempioException è una classe di eccezione. E’ possibile dichiarare più classi di

eccezioni per un metodo.

E’ utile notare che se un metodo dichiara di poter lanciare eccezioni di una

superclasse, può lanciare anche eccezioni delle relative classi derivate.
Un handler viene definito con una sintassi ben precisa.

try{
// istruzioni che lanciano eccezioni
}catch(Esempio1Exception e){
// istruzioni associate all'eccezione di tipo Esempio1Exception
}catch(Esempio2Exception e){
// istruzioni associate all'eccezione di tipo Esempio2Exception
}finally{
// istruzioni "finali"
}

Le istruzioni del blocco che segue try vengono eseguite sotto il controllo dell’handler;
nel suo interno va inserito codice grado di lanciare un eccezione.
Le istruzioni di un blocco catch sono eseguite quando nell’esecuzione del blocco try
viene lanciata un eccezione del tipo corrispondente (o di una sua classe derivata) non
gestita da un handler più interno; la corrispondente variabile è associata all’oggetto
che è stato lanciato.
Le istruzioni del blocco finally vengono sempre eseguite, alla fine del blocco try o dei
blocchi catch eventualmente lanciati; esso è usato tipicamente per rilascio di risorse
od operazioni di ripristino.

Per lanciare un’eccezione, il programmatore deve creare un oggetto della classe che
rappresenta quella determinata eccezione, usando la seguente sintassi:

throw new EsempioException();

Bisogna tener conto che ad un eccezione possono essere associati anche dei
parametri, a differenza dell’esempio riportato.

La classe Throwable in Java descrive tutto ciò che può essere generato come un
eccezione.
In generale esistono due oggetti di tipo Throwable, ossia due gerarchie di ereditarietà:
Error, che rappresenta gli errori in fase di compilazione; Exception, il tipo base che può
essere generato da qualsiasi metodo delle classi della libreria standard e che
rappresenta le eccezioni controllate.
Esiste, inoltre, un’ulteriore classe di eccezioni denominata RuntimeException e che
rappresenta le eccezioni non controllate (unchecked excepetion), ossia gli errori che
possono verificarsi a tempo di esecuzione.

Per ricapitolare, le eccezioni vengono utilizzate per: gestire i problemi nel punto
adeguato, risolverli e chiamare nuovamente il metodo che ha generato l’eccezione;
risolvere il problema e continuare senza richiamare il metodo generatore; calcolare
risultati alternativi a quelli previsti; terminare il programma; semplificare il codice e la
sua manutenzione; rendere il software più sicuro.
I contenitori

Le classi Contenitors sono fra gli strumenti più potenti per lo sviluppo, ed assumono il
compito di “collezionare” gli oggetti.

La libreria dei contenitori si suddivide in due concetti distinti.

Vi sono le Collection, ossia raccolte di più elementi di un determinato tipo (ossia di

oggetti), spesso sottostanti a qualche regole; esse, a loro volta, possono essere o List
o Set.
List deve contenere gli elementi seguendo un criterio preciso di ordinamento lineare, e
può ammettere duplicati, quest’ultima particolarità non ammessa con i Set; la
struttura di dati associata al tipo List è l’ArrayList, quella associata al tipo Set è
l’HashSet. Esiste, inoltre, un’ulteriore tipologia di Set, denominata SortedSet in cui è
garantito l’ordinamento degli elementi; l’unica implementazione possibile è la TreeSet.

La categoria Collection contiene soltanto un elemento in ciascuna posizione.

L’altro concetto che contraddistingue i contenitori riguarda le Map.

Esse sono un gruppo di coppie di oggetti chiave-valore; ogni chiave è univocamente
associata ad un valore.
E’ utile osservare come una Map può restituire un Set delle proprie chiavi, una
Collection dei propri valori od un Set delle proprie coppie. Le strutture dati associate
ad una mappa sono la TreeMap e la HashMap. Nel caso sia importante anche
l’ordinamento è possibile ricorrere alla LinkedHashMap.

La LinkedHashMap utilizza i codici hash su ogni oggetto per velocizzare al massimo

l’operazione di ricerca. Durante lo scorrimento restituisce le coppie a seconda
dell’ordine con la quale essi sono stati inseriti all’interno di essa. Una proprietà
interessante è anche la possibilità di adottare per tale struttura di dati un algoritmo
LRU (last recently used) che restituisce gli elementi secondo il loro ordine di utilizzo.

La scelta di una struttura di dati anziché l’altra è dettata dalla complessità

computazionale associata e dall’utilizzo specifico che di esso si vuol fare E’ noto come
le tabelle hash abbiano un’ottima efficienza per le operazione di inserimento, ricerca
ed estrazione, mentre difettano nella stampa ordinata. Gli alberi, al contempo, sono
più lenti ma consentono di mantenere un ordine ben definito degli elementi inseriti (il
che implica efficienza nella stampa ordinata).

Qui di seguito viene riportato un esempio di implementazione di un contenitore, nello

specifico un Set.

Set setEsempio;
setEsempio = new HashSet();
In tal modo è stato salvaguardato il polimorfismo, ma ciò nonostante è possibile creare
un Set utilizzando direttamente il costruttore di HashSet.

Per le caratteristiche delle interfacce, dei costruttori e metodi è essenziale consultare

la documentazione del linguaggio Java (Javadoc).

Lo svantaggio principale dell’utilizzo dei contenitori è la perdita delle informazioni sul

tipo quando un oggetto viene inserito nel contenitore; difatti essi utilizzano riferimenti
ad Object, che è la radice di tutte le classi risultando di fatto un tipo “universale”.

Gli iteratori

Durante l’utilizzo dei contenitori risulta molto utile ricorrere ad oggetti denominati
Iterator, ossia iteratori.

Essi possono essere intesi come una sorta di “segnaposto” attraverso il quale scorrere
gli elementi immagazzinati.

Per chiedere ad un contenitore di passare un iteratore è necessario utilizzare il metodo

iterator(); tale iterator sarà in grado di restituire il primo elemento della sequenza alla
prima chiamata del suo metodo next().

Le operazioni possibili sono: l’acquisizione dell’oggetto successivo nella sequenza

tramite next(); verificare se esistono altri elementi nella sequenza con hasNext();
eliminare l’ultimo elemento restituito dall’iteratore con remove().

La vera potenza degli iteratori va ricercata nel fatto che essi danno la possibilità do
separare l’operazione di scorrimento di una sequenza dalla sottostanza a tale
sequenza.
La gestione dell’input/output

Le librerie di I/O utilizzano il concetto astratto di flusso, in inglese Stream, che

rappresenta una qualsiasi origine di dati. Il flusso nasconde i dettagli relativi alle
operazioni sui dati all’interno della reale periferica di lettura o scrittura.
Le classi delle librerie Java Il package Java.io è stato strutturato sulla base di due
classi, una per l'input, InputStream, ed una per l'output, OutputStream, che
presentano rispettivamente dei metodi per la lettura (read) e dei metodi per la
scrittura (write). In particolare esiste il metodo per la lettura e la scrittura di un singolo
byte che è astratto.
Per InputStream:

public abstract int read();

Per OutputStream:

public abstract void write(int variabile);

Sull'estensione di queste classi astratte vengono costruite le classi concrete,

relative allo specifico canale che si vuole utilizzare: ci sarà così un
FileInputStream ed un FileOutputStream, per la lettura e scrittura di file. Tra le
altre cose, per poter accedere alla lettura del disco fisso, tali classi devono fare
delle chiamate al sistema operativo.
Il compito di InputStream è quello di rappresentare classi che incapsulano gli
input generati da diverse sorgenti od origini di dati. Tali sorgenti possono
essere: un array di byte; un oggetto di tipo String; un file (quindi un oggetto di
tipo File); una pipe; dati vari, quali ad esempio quelli di connessione.
L’utilizzo di stati di oggetti per aggiungere responsabilità a singoli oggetti di
base in maniera dinamica rappresenta un pattern di programmazione
denominato Decorator; con esso è previsto che tutti gli oggetti che si intende
disporre abbiano la stessa interfaccia, in modo da poter inviare ad essi lo
stesso messaggio. Le classi filtro della libreria Java.io, ossia FilterInputStream e
FilterOutputStream, si ispirano proprio a questo pattern.
Le classi filtro eseguono sue operazioni fondamentalmente diverse. La classe
DataInputStream consente di leggere diversi tipi di dati primitivi per mezzo di metodi
di lettura specifici per byte, int, float a via discorrendo. Le restanti classi modificano,
invece, il comportamento interno di un InputStream, utilizzando, ad esempio, dei
buffer di lettura o tenera traccia dei caratteri letti.

La classe complementare alla DataInputStream è la DataOutputStream, che formatta

ciascuno dei tipi di dato primitivo in un flusso in modo che essi possano venir letti
DataInputStream. A questa classe è correlata la PrintStream, che si occupa della
scrittura dei dati.

Con l’avvento della versione 1.1 del linguaggio Java sono state introdotte le classi
Reader e Writer che, di fatto, per alcune operazioni vanno a sostituire le classi in
precedenza analizzate; quest’ultime, comunque, mantengono intatta la loro efficienza.

Qui di seguito riporto blocchi di codice nel quale vengono utilizzate le classi di cui
discusso.

ObjectInputStream streamLettura = new ObjectInputStream(new

BufferedInputStream(new FileInputStream(fileDaAprire)));
Oggetto oggettoEsempio = (Oggetto) streamLettura.readObject();

ObjectOutputStream streamScrittura = new ObjectOutputStream(new

BufferedOutputStream(new FileOutputStream(fileDaAprire)));
streamScrittura.writeObject(oggettoEsempio);

In relazione alla gestione dell’I/O, risulta molto importante il concetto di

serializzazione.

La serializzazione degli oggetti in Java consente di prendere un qualsiasi oggetto che

implementa l’interfaccia Serializable (implements Serializable) e di convertirlo in una
sequenza di byte che, in un secondo momento, potranno essere ripristinati per
costituire nuovamente l’oggetto originale.

Per serializzare un oggetto è bisogna utilizzare un oggetto di tipo ObjectOutputStream

costruito a partire da un oggetto OutputStream. Fatto ciò, è necessario richiamare il
metodo writeObject() è l’oggetto in questione verrà serializzato e scritto sull’oggetto
OutputStream.

public void scriviSuFile (FileOutputStream file, Oggetto oggettoEsempio)

throws IOException{
ObjectOutputStream out = new ObjectOutputStream(file);
out.writeObject(oggettoEsempio);
}

Analogamente alla fase di scrittura, per la lettura viene utilizzata la classe

ObjectInputStream, costruita a partire da InputStream, ed il metodo readObject(), sul
quale effettuare un’opportuna operazione di cast.
public Oggetto leggiDaFile(FileInputStream file) throws IOException,
ClassNotFoundException{
Oggetto oggettoEsempio = new Oggetto();
ObjectInputStream in = new ObjectInputStream (file);
oggettoEsempio = (Oggetto)in.readObject();
return oggettoEsempio;
}
La concorrenza con i thread

L’esecuzione di un programma comporta l’esecuzione delle sue istruzioni secondo una

sequenza detta sequenza dinamica o flusso di esecuzione (in inglese thread of
execution), possibilmente diversa dalla sequenza statica con cui le istruzioni in
questione sono state scritte. Tradizionalmente, per ogni esecuzione del programma,
c’è un flusso di esecuzione; in sostanza, le istruzioni vengono eseguite in maniera
strettamente sequenziale.
Nei sistemi operativi moderni, d’altronde, è possibile attivare più flussi che, durante
l’esecuzione, procedono in parallelo. Questa caratteristica è la chiave di volta dei
linguaggi denominati multi-threaded.

Nei calcolatori dotati di più processori o cpu multi-core, ogni processore esegue
istruzioni di un diverso thread.
Nelle macchine single-core il processore lavora su più thread, con una tempistica
stabilita dal SO.
In tal caso il parallelismo non è reale, bensì simulato e si parla di esecuzione
concorrente.

Uno dei grandi vantaggi della programmazione multi-threaded sta in un forte

incremento della reattività delle interfacce utente, più in generale dei servizi messi a
disposizione da un software, non più vincolati alla terminazione di un’altra operazione
precedentemente avviata.

I thread che fanno parte della stessa esecuzione condividono le risorse in gioco. Dal
momento che il sistema usa uno stack dei record di attivazione per gestire la
sequenza dinamica, ogni thread ha il proprio stack; con ciò si salvaguarda la
saturazione della memoria nel caso di un elevato numero di concorrenze.
Per attivare un thread in Java occorre creare un oggetto della classe Thread a cui
devono essere associate operazioni da eseguire. Per attivare l’esecuzione del nuovo
thread è necessario ricorrere al metodo start() dell’oggetto di tipo Thread; per fermarla
è possibile utilizzare il metodo stop().
Per effettuare quest’associazione esistono due metodi: creare una classe derivata da
Thread o creare una classe che implementa l’interfaccia Runnable, passando un
oggetto di questa classe al costruttore di Thread.

Nel primo caso, la classe derivata deve ridefinire il metodo public void run() della
classe Thread; il codice del metodo verrà eseguito nel nuovo thread.

Viene dapprima scritta la classe del thread che si desidera creare.

public class NuovoThread extends Thread {

public void run(){

// istruzioni da eseguire all’avvio di un oggetto NuovoThread
}

Ora verrà osservata l’effettiva implementazione di due thread in parallelo all’interno di

un metodo main (che lancia l’esecuzione).

public class TestNuovoThread {

public static void main(String[] args){

Thread t = new NuovoThread();

/*
* viene avviato il thread t contenente le istuzioni
* implementate nel metodo run dell'oggetto NuovoThread
*/
t.start();

/*
* in simultanea al thread t del tipo NuovoThread
* possono essere definite istruzioni eseguite
* nel thread del main
*/
}

}
Nel secondo caso, la classe deve implementare l’unico metodo definito in Runnable,
che ha lo stesso prototipo precedente: public void run().

Analogamente a prima:

public class NuovoThread implements Runnable{

public void run(){

// istruzioni da eseguire all’avvio di un oggetto NuovoThread
}
}

Mentre nel main:

public class TestNuovoThread {

public static void main(String[] args){

NuovoThread oggettoNuovoThread = new NuovoThread();
Thread t = new Thread(oggettoNuovoThread);

/*
* viene avviato il thread t contenente le istuzioni
* implementate nel metodo run dell'oggetto NuovoThread
*/
t.start();

/*
* in simultanea al thread t del tipo NuovoThread
* possono essere definite istruzioni eseguite
* nel thread del main
*/
}

Generalmente si preferisce utilizzare quest’ultima soluzione in quanto: la classe che

implementa Runnable può derivare da un’altra classe già definita nell’applicazione; la
classe che implementa Runnable può definire altri metodi senza rischio di entrare in
conflitto con i metodi già definiti con la classe Thread.

L’esecuzione di un programma multi-threaded normalmente termina quando tutti i

thread hanno completato l’esecuzione delle operazioni richieste. Esiste, tuttavia, la
possibilità di definire thread di servizio (deamon) la cui funzione è subordinata a quella
degli altri thread, per cui il programma ha fine nonostante ci siano deamon attivi, in
soldoni quando tutti i thread non di servizio hanno terminato l’esecuzione.
Un thread è definito come deamon richiamando il metodo public void
setDeamon(true); il metodo deve essere chiamato prima di start().
E’possibile forzare la terminazione di tutti i thread di un applicazione tramite il metodo
public static void exit(int status).
I thread di uno stesso programma possono accedere simultaneamente alle risorse
globali del programma. Da tale caratteristica nasce il problema della sincronizzazione
che serve ad evitare interferenze tra i thread che possono effettuare modifiche in
simultanea ad un'altra concorrenza, generando risultati non corretti.
Per assicurare la mutua esclusione (ossia che nessun thread abbia accesso ad una
risorsa in simultanea con un altro) il sistema operativo mette a disposizione uno
strumento chiamato mutex (mutual exclusion).

Un mutex è un indicatore associato ad una risorsa condivisa. Prima di utilizzare la

risorsa un thread deve acquisire il mutex, segnalando l’utilizzo di quella data risorsa;
una volta effettuata l’operazione richiesta il thread deve rilasciare il mutex,
segnalando che la risorsa condivisa non è più in uso.
Se un thread cerca di acquisire un mutex già acquisito da un altro, il sistema operativo
sospende l’esecuzione sin quando il mutex in questione non viene rilasciato,
garantendo la mutua esclusione.
Il meccanismo descritto funziona, però, solo se tutti i thread cercano di acquisire il
mutex prima di usare la risorsa condivisa; è responsabilità del programmatore
assicurarsi della buona implementazione d’esso.

Se i thread devono accedere contemporaneamente a più di una risorsa condivisa c’è il

rischio che venga creata una situazione di deadlock, in cui ciascun thread ha acquisito
parte delle risorse e viene sospeso in attesa che le altre vengano rilasciate; siccome
gli altri thread risultano tuttavia sospesi, nessuno può rilasciare risorse, generando
una fase di stallo. E’ anche in questo caso responsabilità del programmatore evitare il
verificarsi di deadlock, rispettando un ordine di acquisizione/rilascio mutex identico
per ogni thread.

Ogni oggetto, di qualunque classe, contiene un mutex.

L’uso del mutex di un oggetto di effettua con l’istruzione synchronized secondo la
sintassi:

synchronized (this) {
// istruzioni contenenti risorse comuni
}

Per semplificare la sintassi è possibile aggiungere il qualificatore synchronized

nell’intestazione di un metodo.

public synchronized void metodo() {

// istruzioni contenenti risorse comuni
}
In molti casi un thread deve aspettare il verificarsi di un evento esterno per continuare
la sua elaborazione, come, ad esempio: aspettare per un lasso di tempo prefissato;
attendere che un altro thread abbia terminato la sua esecuzione; attendere che una
struttura di dati condivisa si trovi in un particolare stato.
Il metodo più facile da pensare per realizzare ciò è la cosiddetta attesa attiva,
implementabile tramite un ciclo while ed una condizione. Con questo accorgimento il
thread in attesa si impegna a controllare continuamente il verificarsi della condizione
di sblocco.

E’ evidente come l’attesa attiva comporti un considerevole spreco di risorse di

sistema.
Il metodo di attesa più semplice è quello di sospendere il thread per un intervallo di
tempo stabilito a priori, il tutto attraverso il metodo sleep della classe Thread.

try {
// il thread viene “addormentato”
Thread.sleep(30000);

} catch (InterruptedException e) {
// attesa terminate attraverso un’eccezione
}

Il metodo sleep() è static, quindi si richiama usando direttamente il nome della classe
Thread; esso sospende il thread corrente per un tempo espresso in millisecondi
(msec).

Un thread può mettersi in attesa della terminazione di un altro thread usando uno sei
seguenti metodi della classe Thread: join(), che sospende il thread corrente fino a
quando non termina il thread destinatario del metodo; join(long msec), nel quale viene
specificato anche un tempo di attesa massimo.
Il metodo join va applicato al thread di cui vogliamo aspettare la terminazione.

try {
// viene stabilita l’attesa del thread t
t.join();

} catch (InterruptedException e) { }

// istruzioni da eseguire quando il t termina

Anche il tal caso è necessario un blocco composto da try e catch per gestire
l’eccezione di interruzione.

Nel caso in cui si vuol gestire l’attesa che una struttura di dati si trovi in una situazione
particolare, l’evento che fa risvegliare un thread non è prefissato ma dipende
dall’applicazione; è necessario, indi, un meccanismo più generale. Per realizzare
questo tipo di attesa Java mette a disposizione i metodi wait() e notifyAll(); il primo dei
due mette un thread in attesa che si sia un cambiamento nell’oggetto. Il secondo
avvisa tutti i thread in attesa che è avvenuto un cambiamento.
Il thread che richiama il wait deve aver acquisito il mutex dell’oggetto a cui viene
applicato il metodo. Il mutex viene rilasciato automaticamente ed il thread viene
sospeso fino a quando un altro thread non richiama notifyAll sullo stesso oggeto. Al
suo risveglio il thread riacquisisce il mutex sullo stesso oggetto.
L’acquisizione del mutex è necessaria per consentire al thread di esaminare lo stato di
una struttura di dati condivisa; il rilascio automatico del mutex, che riguarda solo
quello dell’oggetto a cui è applicato il metodo, consente agli altri thread di modificare
la risorsa condivisa. Il thread che richiama wait utilizza, tipicamente, un ciclo di
controllo.
Per quanto riguarda il metodo notifyAll, il thread che lo richiama deve aver acquisito il
mutex.
Tutti i thread in attesa vengono risvegliati, ma vengono eseguiti uno alla volta.

In una classe ben progettata, il codice che gestisce l’attesa della condizione è
incapsulato nei metodi dell’oggetto che contiene la struttura di dati.
L’interfaccia grafica

Un aspetto importante dei linguaggi di programmazione è la possibilità di creare GUI

(graphical user interface).

Java permette la creazione di applet, piccoli programmi che girano all’interno di un

browser web.

Essendo queste applicazione orientate alla rete, è necessario un forte vincolo al

programmatore in quanto è di primaria importanza la salvaguardia della sicurezza. Gli
svantaggi certamente notevoli sono: l’impossibilità di accedere al disco fisso; la
lentezza di un applet nella visualizzazione.
E’ vantaggioso, invece, il fatto che un applet non necessita di installazione e che il
software non è in grado di procurare danni al sistema sul quale gira.

I metodi principali messi a disposizione per la gestione degli applet sono init(), start(),
stop() e destroy().

Init viene chiamato automaticamente per eseguire la prima inizializzazione dell’applet,

compreso il layout dei componenti implementabili nell’interfaccia. Questo metodo sarà
sempre ridefinito.
Start viene chiamato ogni volta che l’applet entra nel campo del browser e serve per
avviare le sue normali operazioni.
Stop viene chiamato ogni qual volta l’applet esce dal campo del browser per
consentire all’applet di terminare le operazioni.
Destroy viene chiamato quando l’applet viene scaricato dalla pagina per eseguire il
rilascio definitivo di tutte le risorse del browser.

Creata un interfaccia grafica è assolutamente necessario associare ai componenti

(pulsanti, aree di testo, menu e via discorrendo) e fare in modo che essi siano in grado
di “catturarli”. Per consentire al programmatore quest’operazione il linguaggio Java
mette a disposizione il metodo addActionListener() che implementa l’interfaccia
ActionListener, la quale contiene come unico metodo denominato ActionPerformed();
quest’ultimo è la chiave della gestione degli eventi in quanto, al suo interno, vanno
inserite le istruzione che si desidera far compiere dallo specifico componente che lo
implementa.

Oltre agli applet è possibile utilizzare anche delle finestre grafiche chiamate Frame (il
cui significato, dall’inglese, è cornice).