Porfirio Tramontana » 6.Class Diagram – parte prima

Class diagram

Il più diffuso diagramma compreso in UML è il diagramma delle classi.
Si tratta di un diagramma statico che può essere utilizzato:

• Per la modellazione concettuale del dominio di un problema;
• Per la modellazione delle specifiche richieste ad un sistema;
• Per modellare l’implementazione (object-oriented) di un sistema software.

I concetti fondamentali di un class diagram sono estensioni dei concetti fondamentali dei paradigmi object-oriented.

Nel seguito verrà presentato il class diagram nella sua accezione più completa, relativa alla modellazione dell’implementazione di sistemi object-oriented.

Aspetti principali

I principali elementi dei class diagram sono:

• Classi
  • Rappresentanti i tipi di dati presenti in un sistema;
• Associazioni
  • Rappresentano i collegamenti fra istanze di classi;
• Attributi
  • Sono i dati semplici presenti nelle classi e nelle loro istanze;
• Operazioni
  • Rappresentano le funzioni svolte dalle classi e dalle loro istanze;
• Generalizzazioni
  • Raggruppano le classi in gerarchie di ereditarietà.

Attributi

visibilità nome molteplicità: tipo = default {proprietà}

Sono consentiti tre livelli di visibilità:
+ Livello pubblico: L’utilizzo viene esteso a tutte le classi;
# Livello protetto: L’utilizzo è consentito soltanto alle classi che derivano dalla classe originale;
- Livello privato: Soltanto la classe originale può utilizzare gli attributi e le operazioni definite come tali.

Il nome dell’attributo é l’unico parametro necessario.

Il tipo dell’attributo può essere un tipo standard (int, double, char, etc…) oppure il nome di una classe definita nello stesso diagramma (in tal caso forse l’attributo andrebbe indicato con un’associazione …).

Default rappresenta il valore di default dell’attributo.

Attributi (segue)

nome molteplicità: tipo = default {proprietà}

La molteplicità indica il quantitativo degli attributi (ad esempio la dimensioni per un array). Tramite la molteplicità è possibile indicare come attributi degli array o matrici. Il valore di default é 1.

Alcuni valori possibili sono:
1 (uno e uno solo). E’ il valore di default;
0..1 (al più uno);
* (un numero imprecisato, eventualmente anche nessuno; equivalente a 0..*);
1..* (almeno uno).

Gli elementi di una molteplicità sono considerati come un insieme.
Se essi sono dotati anche di ordine si aggiunge l’indicazione {ordered}.
Se sono possibili valori duplicati si aggiunge l’indicazione {nonunique}

{proprietà} rappresenta caratteristiche aggiuntive dell’attribute (ad esempio la sola lettura); Esempio: name: String [1] = “Untitled” {readOnly}.

Metodi

visibilità nome (lista parametri) : tipo-ritornato {proprietà}

La visibilità e il nome seguono regole analoghe a quelle degli attributi.

Lista parametri contiene nome e tipo dei parametri della funzione, secondo la forma:
direzione nome parametro: tipo = valore-di-default

direzione: input (in), output (out) o entrambi (inout). Il valore di default é in.
nome, tipo e valore di default sono analoghi a quelli degli attributi.
Tipo-ritornato é il tipo del valore di ritorno: dovrebbe essere un tipo appartenente ad una classe standard.

Esempio:  + balanceOn (date: Date) : Money

Codifica delle associazioni (segue)

Molti a molti (es: molti Studente, molti Esame)

• La classe Studente è implementata avendo anche un attributo array di Esame;
• La classe Esame è implementata avendo anche un attributo array di Studente;
• Entrambe le cose.

Uno a Uno (es: uno Studente, un Badge)

• La classe Badge è implementata avendo un attributo Studente;
• La classe Studente è implementata avendo un attributo Badge;
• Entrambe le cose.

Esempio

Associazione uno a uno

class A {
Public: link(B* linkato):ruolo_di_B(linkato) {}
Private: B* ruolo_di_B;
};

Class B {
Public: link(A* linkato):ruolo_di_A(linkato) {}
Private: A* ruolo_di_A;
};

Void main() {
A a;
B b;
a.link(&b);
b.link(&a);
};

Esempio (segue)

Associazione uno a molti

class A {
Public: aggiungi(B* newobj);
rimuovi(B* oldobj);
Private: lista_puntatori_a_B;
};

Class B {
Public: link(A* linkato):ruolo_di_A(linkato) {}
Private: A* ruolo_di_A;
};

Controesempi

A volte le associazioni uno a uno sono inutili. Soluzione da Evitare.

Migliore soluzione!

Associazioni riflessive

Associazioni che collegano una classe con sè stessa.

Permette, per ogni atleta, di risalire al distacco da tutti gli altri atleti.

Quando usare una aggregazione

Una associazione diventa una aggregazione se:

• È possibile affermare che:
  • Le parti sono ‘parte di’ un insieme;
  • L’aggregato è ‘composto da’ parti.

• Quando qualcosa possiede o controlla l’aggregato, allora esso possiede o controlla anche le sue parti.

Per quanto le aggregazioni siano importante dal punto di vista della espressività del modello, spesso sono implementate in maniera identica rispetto ad associazioni di pari cardinalità.

Una gerarchia di aggregazione

Esercizio proposto: modellare i concetti di file e directory nell'ambito di un file system.

Esempio di aggregazione (uno a uno)

//file Automobile.h
#include "Motore.h"
#include "Carrozzeria.h"
class Automobile {
public:
//il costruttore inizializza Automobile anche in assenza di Motore e Carrozzeria
Automobile(Stringa marca= "", Stringa mod="",..., Motore* mot=0, Carrozzeria* car=0);
...
private:
Carrozzeria* carrozzeria; //traduzione aggregazione
Motore* motore; //traduzione aggregazione
...
};

//file Automobile.cpp
//Costruttore di Automobile
Automobile:: Automobile(Stringa marca, Stringa mod,...,Motore* mot, Carrozzeria* car) :
marca(marca), modello(mod),motore(mot), carrozzeria(car);

Esempio di aggregazione (uno a uno) (segue)

Il programma principale dovrà dapprima creare un oggetto di tipo Carrozzeria e Motore ed infne l’oggetto di tipo Automobile. Ad esempio:

#include "Automobile.h"
main () { //usa classe Automobile
//definisce e inizializza oggetto di tipo Motore
Motore m("AZ123","Ferrari", 6,12,1000);
//definisce e inizializza oggetto di tipo Carrozzeria
Carrozzeria c("12345ASA", "RossoFerrari",1500);
//definisce e inizializza puntatore a motore
Motore* puntatoreMotore=&m;
//definisce e inizializza puntatore a carrozzeria
Carrozzeria* puntatoreCarrozzeria=&c;
//definisce e inizializza oggetto Automobile, fornendo puntatori
Automobile auto1("Ferrari", ..., puntatoreCarrozzeria, puntatoreMotore);
...
} //al termine vengono separatamente distrutti m,c e auto1

Esempio di aggregazione (uno a uno) (segue)

Affinchè si possa parlare di contenimento stretto (composizione) deve essre garantito che la classe Contenitore sia effettivamente l'unica ad accedere al metodo costruttore della classe Contenuto.