Progettazione del Software, Laurea in Ingegneria Gestionale
Università degli Studi di Roma “La Sapienza”
Facoltà di Ingegneria – Corso di Laurea in Ingegneria Gestionale
Corso di Progettazione del Software
Proff. Toni Mancini e Monica Scannapieco
Dipartimento di Informatica e Sistemistica
Università di Roma “La Sapienza”
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati
versione del February 26, 2008
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 1/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Modifiche rispetto alle versioni precedenti
Rispetto alla versione del 6 Marzo 2007
Corretto un errore nella slide n. 19 (Accesso e modifica
degli attributi concettuali)
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 2/22
Progettazione del Software, Laurea in Ingegneria Gestionale
La fase di realizzazione
L’input di questa fase è costituito da:
– L’output della fase di Progetto, formato da:
– Diagramma realizzativo delle classi e degli oggetti
– Specifiche realizzative delle strutture dati, delle classi, e degli use-case
– Tabella della corrispondenza dei tipi;
– Tabelle della rappresentazione degli stati dei diagrammi degli stati e transizioni;
– Vincoli sulla gestione e sull’evoluzione delle proprietà delle classi (attributi e
associazioni).
– Parte dell’output della fase di Analisi, in particolare:
– La specifica delle classi e degli use-case che non è stata raffinata durante la fase
di progetto;
– La specifica concettuale dei tipi di dato (anche se raffinata in fase di Progetto);
– I diagrammi degli stati e delle transizioni
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 3/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Output della fase di Realizzazione
– Un programma Java che realizza in modo completo e corretto la specifica iniziale dei
requisiti, ed è coerente con tutte le scelte fatte in fase di Analisi e di Progetto.
– La documentazione associata al codice.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 4/22
Progettazione del Software, Laurea in Ingegneria Gestionale
La fase di Realizzazione: metodologia
In questa sezione verrà mostrato come realizzare in Java:
– Le strutture dati progettate in fase di Progetto;
– Le classi del diagramma delle classi realizzativo, e le loro operazioni;
– Le associazioni del diagramma delle classi realizzativo;
– I diagrammi degli stati definiti in fase di Analisi e progettati durante la fase di Progetto;
– Gli use-case.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 5/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Realizzazione delle strutture dati
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 6/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Realizzazione delle strutture dati
Per ogni struttura dati da realizzare, è stata prodotta, durante la fase di progetto, una
specifica realizzativa, nella quale è esplicitato:
– Gli attributi (con relativi tipi) che sono stati scelti per rappresentare i valori della
struttura;
– Le operazioni che deve essere possibile effettuare sui valori della struttura (con
eventuali costruttori); nel caso gli attributi realizzativi sono diversi da quelli concettuali
(cf. la specifica concettuale del tipo di dato) tra le operazioni esisteranno sicuramente
quelle che permettono di calcolare il valore degli attributi concettuali a partire da quello
degli attributi realizzativi;
– Lo schema realizzativo che si è scelto per la realizzazione (con o senza side-effect,
con o senza condivisione di memoria);
– Il meccanismo per il controllo dell’uguaglianza tra gli oggetti.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 7/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Realizzazione delle strutture dati (cont.)
La realizzazione della struttura dati S viene effettuata per mezzo di una classe Java S, tale
che:
1. La classe S contiene un campo dato private per ogni attributo realizzativo della
struttura dati, del tipo associato.
2. Se la specifica realizzativa della struttura dati presenta definizioni esplicite di
costruttori, nella classe Java sarà definito un costruttore per ognuno di essi, che
genera un eccezione di class EccezionePrecondizioni nel caso le sue
precondizioni non siano verificate. Nel caso invece la specifica realizzativa non ha
definizioni esplicite di costruttori, ci si comporta come se tale specifica contenesse la
dichiarazione di un unico costruttore con un argomento di input per ogni attributo
concettuale del tipo realizzato dalla struttura dati, che inizializza gli attributi della
classe (corrispondenti agli attributi realizzativi della struttura dati). Tale costruttore non
ha precondizioni (a meno di quelle di carattere generale descritte in seguito).
3. La classe Java conterrà la definizione di operazioni per ottenere ed eventualmente
modificare i valori degli attributi concettuali del tipo di dato che realizza;
4. La classe Java conterrà la definizione di tutte le operazioni definite nella specifica
realizzativa della struttura dati. La realizzazione di tali operazioni seguirà gli algoritmi
presenti nella specifica realizzativa, e sarà quindi coerente con lo schema realizzativo
scelto.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 8/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Realizzazione delle strutture dati (cont.)
5. La classe Java conterrà la ridefinizione dei metodi equals() e hashCode(), al fine di
consentire il controllo dell’uguaglianza profonda tra oggetti, secondo quanto esplicitato
nella specifica realizzativa;
6. La classe Java conterrà la ridefinizione del metodo clone() per consentire la copia
profonda tra oggetti.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 9/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Costruttori
Per ogni costruttore S(arg1 : T 1, . . . argn : T n) della struttura dati S, la corrispondente
classe Java definisce un costruttore di segnatura:
public S(T1 arg1, ..., Tn argn) throws EccezionePrecondizioni
(senza la clausola throws se il costruttore della struttura dati non ha precondizioni e non c’è
necessità di verificare le condizioni di ammissibilità lato server per gli attributi).
Se la specifica realizzativa non ha costruttori (che quindi sono assenti anche nella specifica
concettuale), ci comportiamo come se ne esistesse uno con un argomento per ogni attributo
concettuale.
Nota: abbiamo usato gli stessi simboli S, T k e S e Tk (in font diversi) per indicare le diverse
strutture dati e le classi Java che le realizzano.
Il corpo del costruttore si occuperà di inizializzare opportunamente il valore per gli attributi
della classe, come esplicitato dall’algoritmo sintetizzato in fase di Progetto, e coerentemente
con lo schema realizzativo scelto per realizzare la struttura dati.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 10/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Costruttori (cont.)
Ad esempio, supponiamo che l’attributo attr di tipo T vada inizializzato con il valore di uno
degli argomenti del costruttore, sia arg. Si ha che il costruttore conterrà una tra queste
istruzioni:
– Se T è un tipo base Java: attr = arg;
– Se T è una classe Java che implementa una struttura dati progettata secondo lo
schema “senza side-effect”, allora:
– Se lo schema realizzativo della struttura dati S che stiamo implementando è “con
condivisione”: attr = arg;
– Altrimenti (“senza condivisione”): attr = (T)arg.clone();
– Se T è una classe Java che implementa una struttura dati progettata secondo lo
schema “con side-effect”, allora: attr = (T)arg.clone();
Inoltre, nel caso il tipo Java scelto per arg è semanticamente più esteso del corrispondente
tipo UML, va implementata la verifica delle condizioni di ammissibilità lato server.
Analogo discorso vale, nel caso il tipo di arg sia una classe Java, per evitare di creare
l’oggetto quando arg vale null (a meno che il corrispondente attributo non sia opzionale).
In questi casi, il costruttore deve generare un’opportuna eccezione.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 11/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Costruttori (cont.)
In questo corso, per semplicità, assumiamo che ogni modulo che verifica condizioni di
ammissibilità o precondizioni genera, in caso queste non siano soddisfatte, una eccezione di
classe EccezionePrecondizioni.
Tale classe estende da Exception ed è definita in seguito:
package ProSW;
public class EccezionePrecondizioni extends Exception {
public EccezionePrecondizioni() { super(); }
public EccezionePrecondizioni(String messaggio) { super(messaggio); }
} //:˜
Ovviamente, nei casi reali, è opportuno prevedere una classe distinta per ogni tipologia di
eccezione.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 12/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Esempio: costruttore della classe Data
Dalle specifiche concettuale e realizzativa ricordiamo che:
– Gli attributi concettuali del tipo di dato Data sono giorno : [1..31], mese : [1..12], anno :
intero > 0;
– La specifica concettuale ha un costruttore Data(giorno : [1..31], mese : [1..12], anno :
intero > 0) con delle precondizioni;
– Gli attributi realizzativi della struttura dati che realizza il tipo sono giorno, mese, anno:
int;
– Ovviamente, anche la specifica realizzativa ha un costruttore, raffinamento di quello
sintetizzato in fase di Analisi.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 13/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Esempio: costrutt. classe Data (cont.)
La classe Java Data sarà allora definita nel modo seguente:
public class Data {
private int giorno, mese, anno;
public Data(int g, int m, int a) throws EccezionePrecondizioni {
if (
/* Controllo precondizioni:
1. Se gli argomenti non sono di tipo base, questi non
possono essere null:
/
*
// nulla
/*
2. Verifica ammissibilita’ dei valori per gli arg. il cui tipo Java
e’ semanticamente piu’ esteso del corrisp. tipo UML:
(g >= 0 && g <= 31) && (m >= 0 && m <= 12) && (a > 0)
/*
3. Verifica prec. nella specifica realizzativa
*/
// ...ovvero che g/m/a sia un valore legale del tipo Data... (omesso)
) {
// Precondizioni verificate: Posso creare l’oggetto
giorno = g; mese = m; anno = a;
}
else throw new EccezionePrecondizioni(""+g+"/"+m+"/"+a +
" non e’ un valore legale del tipo Data!");
}
...
}
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 14/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Esempio: costruttore della classe Ora
Dalle specifiche concettuale e realizzativa ricordiamo che:
– Gli attributi concettuali del tipo di dato Ora sono ore : [0..23], min : [0..59], sec : [0..59];
– La specifica concettuale non ha costruttori, dato che ogni combinazione di valori legali
degli attributi concettuali denota un’istanza legale del tipo di dato;
– Gli attributi realizzativi della struttura dati che realizza il tipo sono diversi da quelli
concettuali. In particolare abbiamo sec: int (secondi dalla mezzanotte);
– La specifica realizzativa prevede quindi le operazioni ore(), minuti(), secondi() che
calcolano e ritornano i valori degli attributi concettuali a partire da quelli degli attributi
realizzativi;
– La specifica realizzativa non ha costruttori: ci comportiamo come se ne avesse uno
con segnatura Ora(ore:int, minuti:int, secondi:int) (con un argomento per ogni attributo
concettuale).
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 15/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Esempio: costr. classe Ora (cont.)
La classe Java Ora sarà allora definita nel modo seguente:
public class Ora {
private int sec;
public Ora(int ore, int minuti, int secondi) throws EccezionePrecondizioni {
if (
/* Controllo precondizioni:
1. Se gli argomenti non sono di tipo base, questi non
possono essere null:
/
*
// nulla
/*
2. Verifica ammissibilita’ dei valori per gli arg. il cui tipo Java
e’ semanticamente piu’ esteso del corrisp. tipo UML:
(ore >= 0 && ore < 24) && (minuti >= 0 && minuti < 60) &&
(secondi >= 0 && secondi < 60)
/*
3. Verifica prec. nella specifica realizzativa
*/
// nulla
) {
// Precondizioni verificate: Posso creare l’oggetto
sec = secondi + minuti*60 + ore*3600;
}
else throw new EccezionePrecondizioni(""+ore+":"+minuti+":"+secondi +
" non e’ un valore legale del tipo Ora!");
}
...
}
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 16/22
Progettazione del Software, Laurea in Ingegneria Gestionale
: costrutt. classe DataOra (senza side-effect, co
Dalle specifiche concettuale e realizzativa ricordiamo che:
– Gli attributi concettuali del tipo di dato DataOra sono data : Data, ora : Ora;
– La specifica concettuale non ha costruttori;
– Gli attributi realizzativi della struttura dati che realizza il tipo sono data : Data, ora :
Ora;
– La specifica realizzativa non ha costruttori: ci comportiamo come se ne avesse uno
con segnatura DataOra(data:Data, ora:Ora) (con un argomento per ogni attributo
concettuale).
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 17/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Esempio: costr. classe DataOra (cont.)
La classe Java Data sarà allora definita nel modo seguente:
public class DataOra {
private Data data;
private Ora ora;
public DataOra(Data d, Ora o) throws EccezionePrecondizioni {
if (
/* Controllo precondizioni:
1. Se gli argomenti non sono di tipo base, questi non
possono essere null:
/
*
(d != null && o != null)
/*
2. Verifica ammissibilita’ dei valori per gli arg. il cui tipo Java
e’ semanticamente piu’ esteso del corrisp. tipo UML:
// nulla
/*
3. Verifica prec. nella specifica realizzativa
*/
// nulla
) {
// Precondizioni verificate: Posso creare l’oggetto:
data = d; // Se Data non permette side-effect e DataOra permette condiv.
// altrimenti: data = (Data)d.clone();
ora = o; // Se la classe Ora non permette side-effect e DataOra permette condiv.
// altrimenti: ora = (Ora)o.clone();
}
else throw new EccezionePrecondizioni(""+d+", " + o +
" non e’ un valore legale del tipo DataOra!");
}
...
}
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 18/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Accesso e modif. degli attrib. concettuali
Tra le operazioni della class Java avremo sicuramente quelle per accedere (ed
eventualmente manipolare) il valore degli attributi concettuali del tipo di dato che la classe
Java realizza.
In particolare, per ogni attributo concettuale attr: T, si ha un metodo public T getAttr(),
definito come segue:
– Nel caso T sia un tipo base:
return attr;
– Nel caso T sia una classe:
– Se T non permette side-effect:
return attr;
– Altrimenti:
return (T)attr.clone();
Inoltre:
– se lo schema realizzativo è con side-effect, per ogni attributo concettuale attr: T, si
ha un metodo public void setAttr(T x) il cui corpo è definito in modo del tutto analogo
a quanto descritto a proposito dei costruttori (ovvero assegnando ad attr il valore di
x se T è un tipo base oppure se T è una classe che non permette side-effect e la
struttura che stiamo realizzando permette la condivisione di memoria, oppure, in caso
contrario, clonando l’oggetto puntato da x ed assegnando il riferimento del clone ad
attr).
Il comportamento dei metodi get...() e set...() viene generalizzato nel modo già visto
per i costruttori nel caso gli attributi realizzativi siano diversi da quelli concettuali.
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 19/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Esempio: la classe Data
Vediamo i metodi della classe Java Data per accedere agli attributi concettuali del tipo:
public class Data {
private int giorno, mese, anno;
public Data(int g, int m, int a) throws EccezionePrecondizioni { ... }
public int getGiorno() { return giorno; }
public int getMese() { return mese; }
public int getAnno() { return anno; }
// Nel caso la classe Data segua lo schema ’con side-effect’:
public void setGiorno(int g) throws EccezionePrecondizioni {
if (g>=1 && g <= 31 && /* "g/mese/anno" e’ un’istanza legale */ ) {
giorno = g;
} else throw new EccezionePrecondizioni(""+g+"/"+mese+"/"+anno +
" non e’ un valore legale del tipo Data");
}
// Idem per setMese() e setAnno();
...
}
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 20/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Esempio: la classe Ora
I metodi della classe Java Ora per accedere agli attributi concettuali del tipo sono invece:
public class Ora {
private int sec;
public Ora(int ore, int minuti, int secondi) throws EccezionePrecondizioni {
public int getOre() { return (int)Math.floor(sec*1.0/3600); }
public int getMinuti() { return (int)Math.floor( (sec % 3600) *1.0/60); };
public int getSecondi() { return sec % 60; }
// Nel caso la classe Ora segua lo schema ’con side-effect’:
public void setOre(int ore) throws EccezionePrecondizioni {
if (ore>=0 && ore < 24) {
int this_ore = getOre();
sec += (ore-this_ore)*3600;
} else throw new EccezionePrecondizioni(""+ore+"/"+
getMinuti()+"/"+getSecondi() +
" non e’ un valore legale del tipo Ora");
}
// Idem per setMinuti() e setSecondi();
...
}
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 21/22
Progettazione del Software, Laurea in Ingegneria Gestionale
Esempio: la classe DataOra
I metodi della classe Java DataOra per accedere agli attributi concettuali del tipo sono
invece:
public class DataOra {
private Data data;
private Ora ora;
public DataOra(Data d, Ora o) throws EccezionePrecondizioni { ... }
public int getData() {
return data; // se Data non permette side-effect
// Altrimenti: return (Data)data.clone();
}
// Idem per getOra()
// Nel caso la classe DataOra segua lo schema ’con side-effect’:
public void setData(Data d) throws EccezionePrecondizioni {
if (d != null) {
data = d; // se Data non perm. side-effect, e DataOra perm. condiv.
// Altrimenti: data = (Data)d.clone();
} else throw new EccezionePrecondizioni(...);
}
// Idem per setOra()
...
}
T. Mancini & M. Scannapieco
S.R.1 – La fase di Realizzazione: realizzazione di strutture dati – February 26, 2008 – p. 22/22