Attività 1
Introduzione alla OOP
Idee di base della OOP:


Strutturare i programmi in modo da riflettere l’ordine
delle cose nel mondo reale
Focus dell’attenzione è il sistema che si vuole
analizzare
Un sistema è costituito da un insieme di componenti
indipendenti che possono interagire tra loro
1
Esempio: assemblaggio di un personal computer attraverso componenti
indipendenti (ad esempio, la scheda video, il microprocessore, scheda
madre, tastiera,…ecc..).
Ognuno di questi componente contribuisce a costituire
il sistema più complesso “PC”, che funziona grazie ad un meccanismo di
interazione tra le sue unità.
• Ciascun componente può essere prodotto da case costruttrici
diverse purché sia compatibile con gli altri e deve rendere noto il
modo in cui dialoga con l’esterno.
• I produttori dei vari componenti devono conoscere solo le
funzionalità dei diversi componenti e non i dettagli tecnici
La logica della OOP opera sulla base degli stessi
presupposti:
• Un programma è formato da varie componenti autonome, dette
oggetti,ciascuna con una propria struttura non resa nota ad altri oggetti
• Ciascuna componente (oggetto) comunica con gli altri secondo modi
prestabiliti
•Ciascuna componente (oggetto) svolge un ruolo specifico
2
Le classi e gli oggetti
Una classe è un modello astratto generico per una
famiglia di oggetti con caratteristiche comuni
Esempio: La classe Processore che descrive le caratteristiche
comuni a tutti i processori non è ancora un esemplare concreto
di processore, è uno “stampo”
Un’istanza (o oggetto) è la rappresentazione concreta
e specifica di un elemento che appartiene alla classe
3
Una classe si compone generalmente di due parti:
Attributi: proprietà o caratteristiche che tutti gli oggetti della
classe devono possedere, I loro valori determinano, in un certo
istante, lo stato di ogni singolo oggetto della classe.
Metodi: specificano le funzionalità che la classe offre. I metodi
corrispondono ai comportamenti dell’oggetto.
Esempio: Determinare gli attributi e i metodi di una classe denominata Motocicletta:
Attributi
Marca:
Modello:
Colore:
Cilindrata:
StatoMotore:
MarciaInserita:
Metodi
AvviaMotore
SpegniMotore
Accelera
CambiaMarcia
èGuasta?
èInRiserva?
èAccesa?
Possibili valori degli attributi
Marca1, Marca2, Marca3
Strada, Enduro, Corsa
Rosso, verde, bianco
rappresentano lo stato
125, 250, 500
Vero (acceso), Falso (spento)
Prima, Seconda, terza
modificano lo stato
comunicano lo stato
4
Dichiarazione in pseudo-codifica della classe Motocicletta:
Classe Motocicletta
Inizio
Marca:Stringa
/* variabile istanza */
Colore:Stringa
/* variabile istanza */
StatoMotore:Booleano
/* variabile istanza */
Serbatoio:Intero
/* variabile istanza */
Serbatoio  0
/* inizializzazione delle variabili istanza */
StatoMotore  Falso
AvviaMotore()
/* Metodo */
Inizio
Se (StatoMotore=Vero)
Allora
Scrivi(‘Il motore è già acceso’)
Altrimenti
StatoMotore  Vero
Scrivi(‘Il motore è stato acceso’)
FineSe
Fine
Rifornimento (B:Intero):Intero
/* Metodo */
Inizio
Serbatoio  Serbatoio + B
Ritorno(Serbatoio)
Fine
Fine /* Classe */
Esercizi proposti: Descrivere in pseudo-codifica le classi: Automobile,Triangolo, Cerchio
5
Attività 2
Rappresentazione grafica delle classi

UML(Unified Modeling Language):Metodologia di analisi e progettazione a oggetti.
I diagrammi UML per le classi sono costituiti da un rettangolo
diviso in tre sezioni:

Nome della classe

Elenco degli attributi

Elenco dei metodi
Nome Classe
Motocicletta
Marca:Stringa
Colore:Stringa
Cilindrata:Intero
StatoMotore:Booleano
Serbatoio:Intero
AvviaMotore ()
Rifornimento (IN B:Intero):Intero
MostraStato()
Attributi
Modificatore
Modificatore
Query
Metodi
6
I metodi si posso distinguere in:
• Metodi modificatori servono per cambiare lo stato dell’oggetto
• Metodi query servono solo per comunicare lo stato all’esterno
• Metodi Costruttori servono per creare ed inizializzare lo stato di un nuovo
oggetto
L’ UML si serve anche di altre parole chiave come:
- IN per i parametri utilizzati in input
- OUT per i parametri restituiti in output
- IN/OUT per i parametri di input/output
Gli attributi e i metodi di una classe dipendono strettamente dal
contesto in cui viene utilizzata la classe
7
Creazione di una istanza e metodi costruttori
La creazione di una istanza avviene attraverso due fasi:
 Dichiarazione stessa sintassi seguita per la dichiarazione delle variabili
 Allocazione riservare area di memoria che possa contenere l’oggetto
Per allocare memoria utilizzeremo l’operatore Nuovo preceduto dal nome della classe
di cui si vuole creare il nuovo oggetto e seguito dal nome del costruttore della classe
Il Costruttore di classe è un metodo speciale

può essere esplicitamente dichiarato o meno nella classe ma è sempre presente.

Crea e inizializza il nuovo oggetto e deve avere lo stesso nome della classe
Sintassi per allocare memoria:
<NomeIstanza>  Nuovo <NomeMetodoCostruttore>([ListaParametri])
Dichiarazione e allocazione insieme:
<NomeClasse><NomeIstanza>  Nuovo <NomeMetodoCostruttore>([ListaParametri])
Esempio:Motocicletta Moto1  Nuovo Motocicletta()
8
Cosa accade nella memoria:
Dichiarazione dell’oggetto
Motocicletta moto1
Viene allocato spazio per contenere
un indirizzo
Moto1
Allocazione dell’oggetto
Moto1  Nuovo Motocicletta()
Crea in memoria lo spazio per contenere
l’oggetto Motocicletta con tutti i suoi attributi
e inserisce nella variabile un riferimento a
tale area di memoria
Moto1
………………
Area di
memoria per
gli attributi
Una istanza di classe può contenere o un riferimento a un oggetto o Nil, se contiene
Nil non fa riferimento ad alcun oggetto
9
In una classe si posso definire più costruttori, tutti con lo stesso
nome, che si differenziano nella segnatura (nome, tipo valore di
ritorno, lista parametri).
I costruttori hanno lo scopo di:
• Inizializzare un nuovo oggetto con le sue variabili, specificare lo stato
iniziale dell’oggetto
• Compiono tutte le operazioni necessarie alla nascita dell’oggetto
Aggiungiamo due nuovi costruttori alla classe Motocicletta e un nuovo
attributo CapacitàMax:Intero
10
Ampliamento della classe Motocicletta
Classe Motocicletta
Inizio
Marca:Stringa
/* variabile istanza */
Colore:Stringa
/* variabile istanza */
Cilindrata:Intero
/* variabile istanza */
StatoMotore:Booleano
/* variabile istanza */
Serbatoio:Intero
/* variabile istanza */
CapacitàMax:Intero
/* variabile istanza */
CapacitàMax  15
/* inizializ. della variabile di istanza */
Motocicletta (mMarca:Stringa, mColore:Stringa, mCilindrata:Intero) /* Primo costruttore */
Inizio
Marca  mMarca
Colore  mColore
Cilindrata  mCilindrata
Fine
Motocicletta (mMarca:Stringa, mColore:Stringa, mCilindrata:Intero, mBenzina:Intero, mStatoMotore:booleano)
Inizio
/*Secondo costruttore */
Marca  mMarca
Colore  mColore
Cilindrata  mCilindrata
Se mBenzina ≤ CapacitàMax
Allora
Serbatoio  mBenzina
Altrimenti
Scrivi (‘Troppa Benzina’)
FineSe
StatoMotore Falso
Fine
AvviaMotore()
/* Metodo */
MostraStato ()
Inizio
Inizio
…….
Scrivi(‘Questa motocicletta è una ‘, Marca’, ‘ ’, Cilindrata, ‘ ’, Colore)
Fine
Scrivi(‘’Serbatoio=‘,Serbatoio, ‘litri di carburante’)
Rifornimento (B:Intero):Intero
/* Metodo */
Se (StatoMotore=Vero)
Inizio
Allora
……
Scrivi(‘Il motore ora è acceso’)
Fine
Altrimenti
MostraStato ()
Scrivi(‘ Il motore ora è spento’)
Inizio
FineSe
….
/Metodo Query */
Fine
11
Fine
Fine /* Classe */
In notazione UML avremo
Motocicletta
Marca:Stringa
Colore:Stringa
Cilindrata:Intero
StatoMotore:Booleano
Serbatoio:Intero
Motocicletta(IN mMarca:Stringa, IN mColore:Stringa, IN mCilindrata:Intero)
Costruttore
Motocicletta(IN mMarca:Stringa, IN mColore:Stringa, IN mCilindrata:Intero, IN
mBenzina:Intero, IN mStatoMotore:booleano)
Costruttore
AvviaMotore ()
Modificatore
Rifornimento (IN B:Intero):Intero
Modificatore
MostraStato()
Query
12
Rappresentazione grafica di un oggetto
Creiamo un nuovo oggetto di Classe Motocicletta: Moto2 con il secondo costruttore
Motocicletta Moto2  Nuovo Motocicletta(‘Marca2’, ‘Giallo’,750,10)
Utilizzando la metodologia UML si può creare anche un
diagramma degli oggetti
Nome Istanza
Moto2
Istanza di
Motocicletta
Colore’Giallo’
Marca’Marca2’
Cilindrata750
StatoMotoreFalso
Serbatoio10
Attributi e valori
13
Attività 3
Interazione tra oggetti
Gli oggetti interagiscono tramite l’invio di messaggi
Messaggio

Nome oggetto Destinatario

Nome del metodo dell’oggetto destinatario che si vuole attivare detto Selettore

Elenco dei parametri attuali che vengono passati al Selettore
In pseudo-codice
<NomeOggetto>.<NomeMetodo>([ListaParametri])
Esempio
Moto2. AviaMotore()
Moto2. Rifornimento(5)
Dot-Notation
14
Quando arriva un messaggio all’oggetto destinatario questo ultimo controlla se
tra i suoi metodi esiste il metodo con la stessa segnatura del Selettore del
messaggio. Se Esiste lo manda in esecuzione.
Oggetto mittente
Oggetto destinatario
Moto2
Istanza di
Motocicletta
Moto2
Istanza di
Motocicletta
Colore
Marca
Cilindrata
StatoMotore
Serbatoio
Colore
Marca
Cilindrata
StatoMotore
Serbatoio
Rifornimento(B: Intero)
AvviaMotore()
)
Messaggio
Moto2.Rifornimento(5)
Metodi richiamabili
dall’esterno
Rifornimento(B: Intero)
AvviaMotore()
MostraStato()
15
Accesso agli Attributi
<NomeOggetto>.<NomeAttributo>
Esempio: Impostare la cilindrata di Moto2 a 750
Moto2.Cilindrata  750
Per accedere sempre e comunque a un qualsiasi attributo di un oggetto si usano dei
metodo particolari:
• Metodi Set() Metodi che modificano uno o più attributi di un oggetto
• Metodi Get() Metodo che restituisce un valore dello stato dell’oggetto
Sintassi:
Get<NomeAttributo>()
Set<NomeAttributo>()
N.B. E’ conveniente sempre accedere ad un attributo con un metodo Set() o
Get() e mai in modo diretto
16
Riprendiamo la nostra classe Motocicletta e aggiungiamo due metodi uno Set() e uno Get()
Classe Motocicletta
Inizio
Marca:Stringa
/* variabile istanza */
Colore:Stringa
/* variabile istanza */
Cilindrata:Intero
/* variabile istanza */
StatoMotore:Booleano
/* variabile istanza */
Serbatoio:Intero
/* variabile istanza */
CapacitàMax:Intero
/* variabile istanza */
Motocicletta (mMarca:Stringa, mColore:Stringa, mCilindrata:Intero) /*
Primo costruttore */
Inizio
Marca  mMarca
Colore  mColore
Cilindrata  mCilindrata
CapacitàMax 5
StatoMotore  false
Fine
Motocicletta (mMarca:Stringa, mColore:Stringa, mCilindrata:Intero,
mBenzina:Intero, mStatoMotore:booleano)
Inizio
/*Secondo costruttore */
Marca  mMarca
Colore  mColore
Cilindrata  mCilindrata
CapacitàMax 5
Se mBenzina ≤ CapacitàMax
Allora
Serbatoio  mBenzina
Altrimenti
Scrivi (‘Troppa Benzina’)
FineSe
StatoMotore Falso
Fine
AvviaMotore()
/* Metodo */
Inizio
Se (StatoMotore=Vero)
Allora
Scrivi(‘Il motore è già acceso’)
Altrimenti
StatoMotore  Vero
Scrivi(‘Il motore è stato acceso’)
FineSe
Fine
SetSerbatoio(B:Intero)
Inizio
Se ((B+Serbatoio) < CapacitàMax )
Allora
Serbatoio  Serbatoio + B
Altrimenti
Scrivi(‘Il carburante eccede la capacità massima’)
FineSe
Fine
GetSerbatoio()
Inizio
Scrivi(‘Il livello di carburante è:’, Serbatoio)
Fine
MostraStato ()
Inizio
Scrivi(‘Questa motocicletta è una ‘, Marca’, ‘ ’, Cilindrata, ‘ ’,
Colore)
Scrivi(‘’Serbatoio=‘,Serbatoio, ‘litri di carburante’)
Se (StatoMotore=Vero)
Allora
Scrivi(‘Il motore ora è acceso’)
Altrimenti
Scrivi(‘ Il motore ora è spento’)
FineSe
Fine
Fine /*Classe*/
17
Diagramma UML
Motocicletta
Marca:Stringa
Colore:Stringa
Cilindrata:Intero
StatoMotore:Booleano
Serbatoio:Intero
Motocicletta(IN mMarca:Stringa, IN mColore:Stringa, IN mCilindrata:Intero)
Costruttore
Motocicletta(IN mMarca:Stringa, IN mColore:Stringa, IN mCilindrata:Intero, IN
mBenzina:Intero, IN mStatoMotore:booleano)
Costruttore
AvviaMotore ()
Modificatore
MostraStato()
Query
SetSerbatoio(B:intero)
Modificatore
GetSerbatoio()
Query
18
Metodo Main: Applicazione che utilizza le classi definite
Può essere definito:
•
All’interno di una stessa Classe
•
In un’altra Classe
Esempio
Classe Motocicletta
Inizio
………
Fine
Classe TestMotocicletta
Inizio
Main()
Inizio
………
Fine
Fine /*Classe TestMotocicletta*/
Creiamo una istanza T1 della classe TestMotocicletta e invochiamiamo il suo
metodo Main()
TestMotocicletta T1  Nuovo TestMotocicletta()
T1.Main()
19
L’esecuzione delle due istruzioni sarà affidata al compilatore/interprete del linguaggio di
programmazione usato.
Pseudo-codice relativo al Main()
1) Main()
2) Inizio /*Main*/
3)
Motocicletta M Nuovo Motocicletta(‘Marca1’,’Rosso’,650,10)
4)
Scrivi(‘Chiamo metodo MostraStato()…’)
5)
M.MostraStato()
6)
Scrivi(‘-----------’)
7)
Scrivi(‘Avvio il Motore….’)
8)
M.AvviaMotore()
9)
Scrivi(‘-----------’)
10)
Scrivi(‘Chiamo il metodo SetSerbatoio()…’)
11)
M.setSerbatoio(59
12)
Scrivi(‘---------’)
13)
Scrivi(‘Chiamo il metodo MostraStato()….’)
14)
M.MostraStato()
15)
Scrivi(‘---------’)
16)
Scrivi(‘Avvio il motore…’)
17)
M.AvviaMotore()
18) Fine /*Main*/
Analisi del metodo Main()
N° Riga
Effetto
3
Dichiarazione e generazione della
nuova istanza M di classe
Motocicletta
4
Visualizza l’avviso che sta per essere
richiamato il metodo MostraStato()
5
Richiama il metodo MostraStato() per
l’oggetto M. Visualizza i valori delle
variabili istanza di M.Prima si crea un
oggetto poi si può richiamare un
metodo che opera su quell’oggetto
6-9-12-15
Visualizza una linea di separazione
8
Richiama AvviaMotore() dell’oggetto
M che era spento, ora è acceso
11
Richiama il metodo SetSerbatoio(5)
Aggiungendo altri 5 litri di carburante
14
Visualizza di nuovo i valori delle
variabili istanza. Ora il motore risulta
acceso e il serbatoio pieno
17
Tenta di accendere nuovamente il
motore, ma poiché è già acceso
viene visualizzato un messaggio
d’errore:”il motore è gia acceso”.
20
Attività 4
Verifica in itinere delle conoscenze: Test V/F
Tempo 20 minuti
V
1.
Un attributo può essere modificato tramite un metodo
2.
La classe Bicicletta è un modello astratto del concetto di
bicicletta
3.
Istanza di una classe e oggetto di una classe sono due cose
diverse
4.
Istanza e variabile istanza sono la stessa cosa
5.
Un attributo rappresenta una proprietà di un oggetto
6.
E’ possibile avere 5 metodi costruttori con lo stesso nome
7.
Un attributo può essere accessibile direttamente
8.
Un metodo Set() è un metodo che restituisce un valore
9.
Un metodo Get() è sempre un metodo Query
10.
Definire una classe è come creare un oggetto
F
21
Verifica in itinere delle conoscenze:
Quesiti a risposta aperta
tempo 40 minuti
1.
2.
3.
4.
5.
6.
7.
8.
Qual è la differenza tra istanza e variabile istanza?
Qual è la differenza tra classe e istanza?
Qual è la differenza tra variabile istanza e variabile locale?
Da che cosa è rappresentato lo stato di un oggetto?
Come è possibile modificare lo stato e come leggerlo?
Che differenza c’è tra metodo Set() e metodo Get()?
Che cos’è un metodo costruttore?
Che cos’è un metodo Query?
22
Attività 5
L’interfaccia con l’esterno: Incapsulamento e
information hiding
Interfaccia con l’esterno: lista di attributi e metodi (solo la
segnatura) che l’oggetto rende noti all’esterno e che sono
utilizzabili per interagire con esso
Attraverso l’interfaccia, l’oggetto chiamante, conosce il modo per interagire
con l’oggetto chiamato, ignorando i dettagli implementativi di quest’
ultimo
Clausole di visibilità
Nome
Prefisso
UML
Significato
Pubblico
+
Rende visibile
all’esterno la
Sintassi:
segnatura di un
metodo e gli attributi <ClausolaDiVisibilità><Nomemetodo>([<List.Par>]):[<TipoRitorno>]
che precede
<ClausolaDiVisibilità><NomeAttributo>:<TipoAttributo>]
Privato
-
Nasconde all’esterno
la segnatura di un
metodo e l’attributo
che precede
23
Information hiding: Capacità di un oggetto di nascondere i dettagli
implementativi di un suo metodo, rendere noto all’esterno solo la sua segnatura
questo per due motivi:
•In futuro si potrebbe avere la necessità di cambiare la
rappresentazione dello stato
•Impedire che lo stato dell’oggetto possa essere corrotto
Il vantaggio dell’information hiding per l’oggetto consiste nel poter
modificare in modo trasparente l’implementazione
Incapsulamento: legare insieme dati e metodi propri dell’oggetto
Con capsula indichiamo che l’implementazione concreta dell’oggetto non
interessa a nessuno dei programmi clienti. Tali programmi si devono basare solo
sul comportamento pubblico dell’oggetto
24
Applicazione delle regole di visibilità alla classe Motocicletta
Classe Motocicletta
Inizio
Pubblico Marca:Stringa
Pubblico Colore:Stringa
Pubblico Cilindrata:Intero
Pubblico StatoMotore:Booleano
Privato Serbatoio:Intero
Privato CapacitàMax:Intero
Privato CheckOlio:Booleano
Privato CheckFreni:Booleano
Pubblico Motocicletta (mMarca:Stringa, mColore:Stringa, mCilindrata:Intero) /* Primo costruttore */
Inizio
…..
Fine
Pubblico Motocicletta (mMarca:Stringa, mColore:Stringa, mCilindrata:Intero,
mBenzina:Intero, mStatoMotore:booleano)
Inizio
/*Secondo costruttore */
…….
Fine
Pubblico AvviaMotore()
/* Metodo */
Inizio
…….
Fine
Pubblico Set (B:Intero):Intero
/* Metodo */
Inizio
……
Fine
MostraStato ()
Inizio
….
/Metodo Query */
Fine
Fine /* Classe */
25
Diagramma UML
Motocicletta
+Marca:Stringa
+Colore:Stringa
+Cilindrata:Intero
+StatoMotore:Booleano
-Serbatoio:Intero
-CapacitàMax:Intero
-CeckOlio:Booleano
-Ceckfreni:Booleano
Attributi Pubblici
Attributi Privati
+Motocicletta(IN mMarca:Stringa, IN mColore:Stringa, IN mCilindrata:Intero)
Costruttore
+Motocicletta(IN mMarca:Stringa, IN mColore:Stringa, IN mCilindrata:Intero, IN
mBenzina:Intero, IN mStatoMotore:booleano)
Costruttore
+AvviaMotore ()
Modificatore
+SetSerbatoio (IN B:Intero):Intero
Modificatore
+MostraStato()
Query
26
Oggetti come parametri e come valori di ritorno
Un metodo può prendere come parametri istanze di oggetti e
restituire come valore di ritorno un nuovo oggetto
Definizione di una nuova classe Punto
Diagramma UML
Punto
+X:Reale
+Y:Reale
+Punto()
+Punto(IN x1:Reale)
+Punto(IN x1:Reale, IN Y1:Reale):Reale
+Distanza (IN P:Punto):Reale
Costruttore
Costruttore
Costruttore
Query
27
Classe Punto
Inizio
Pubblico X:Reale
Pubblico Y:Reale
Pubblico Punto()
Inizio
X 0
Y 0
Fine
Pubblico Punto(X1:Reale)
Inizio
X X1
Y 0
Fine
Pubblico Punto(X1:Reale, Y1:Reale)
Inizio
X X1
Y Y1
/* variabile istanza */
/*Primo metodo costruttore crea un punto nell’origine*/
/*Secondo metodo costruttore crea un punto sull’asse X*/
/*Terzo costruttore crea un punto in un posto qualsiasi */
Se si vuole usare lo stesso nome
di un attributo o di un metodo per
una variabile locale o un
parametro
Fine
Pubblico Distanza(P:Punto):Reale
R:Reale
Inizio
RRadiceq((OggettoCorrente.X - P.X)2 +(OggettoCorrente.Y – P.Y)2 )
/*Radiceq=radice quadrata */
Ritorno(R)
Fine
Fine /*Classe*/
28
Main()
X1,Y1:Reale
Inizio
Punto P0 Nuovo Punto()
Scrivi(‘ Inserisci il valore di X:’)
Leggi(X1)
Scrivi(‘ Inserisci il valore di Y:’)
Leggi(Y1)
Punto P1 Nuovo Punto(X1,X2)
P0.Distanza(P1)
Fine /*Main*/
/*Punto Origine degli assi*/
Esercizi proposti:
• Progettare con un diagramma UML e in Pseudo-codifica Una
classe Libro
• Progettare con un diagramma UML e in pseudo-codifica una
classe Triangolo
29
Attività 6
Variabili e metodi di classe
Variabile di classe: Il valore di una variabile di classe è depositato
all’interno della classe
Modificando tale valore il cambiamento avrà effetto su tutte le
istanze di quella classe
Definizione di una variabile di classe:
Statico<NomeAttributo>:<TipoAttributo>
Esempio riferito alla classe Motocicletta:
Statico NumeroRuote:Intero
NumeroRuote 2
In questo caso tutte le istanze che si creeranno della classe
motocicletta avranno un numeroRuote pari a due
30
Metodo di classe: Si applica alla classe e si può richiamare
indipendentemente dall’esistenza di una istanza della relativa
classe
Per richiamare un metodo di classe si fa precedere il nome della
classe al nome del metodo
Definizione di metodo di classe
Statico<NomeMetodo>([<ListaParametri>]):[<TipoValoreRitorno>]
Aggiungiamo come esempio alla classe punto un metodo di Classe
Pubblico Statico Distanza(P1:Punto, P2:Punto):Reale
R:Reale
Inizio
RRadiceq((P1.X - P.X)2 +(P1.Y – P.Y)2 )
/*Radiceq=radice quadrata */
Ritorno(R)
Fine
Main()
D:Reale
Inizio
Punto P2 Nuovo Punto(12,23)
Punto P2 Nuovo Punto(34,45)
D Punto.Distanza(P1,P2)
Fine /*Main*/
Esercizio proposto: Aggiungere alla classe punto un metodo che calcoli il
punto medio tra due punti forniti in input
31
Attività 7
Ereditarietà, gerarchie di classi
Ereditarietà: Possibilità di definire una nuova classe ereditando metodi e
attributi di altre classi
Definire una sottoclasse di una classe già esistente significa definire solo le
caratteristiche peculiari che la contraddistinguono dalla
classe(superclasse), poiché le altre vengono direttamente in eredità.
Questo meccanismo consente di specializzare classi già esistenti e quindi
favorisce il riutilizzo del software
Gerarchia di classi:

Ad ogni classe possono essere associate una o più classi che la
precedono immediatamente sopra la gerarchia (le sue superclassi)

Ad ogni classe possono essere associate una o più classi che la
seguono immediatamente sotto la gerarchia (le sue sottoclassi)
32
Rappresentazione con un diagramma UML di una gerarchia di classe
VeicoloAMotore
Metodo ereditato
Metodo ereditato
Generalizzazione
+AvviaMotore()
+MostraStato()
VeicoloA2Ruote
Automobile
Eredita
Specializzazione
Scooter
Metodo ridefinito
Metodo esteso
Ciclomotore
Motocicletta
+MostraStato()
+SostegnoLaterale():Booleano
33
Una sottoclasse può:
• Ereditare metodi e attributi dalla Superclasse
• Estendere la Superclasse aggiungendo nuovi metodi e attributi
•Ridefinire attributi e metodi della Superclasse
Definizione in pseudo-codice di una sottoclasse:
Classe <NomeSottoclasse> Eredita
<NomeSuperclasse>
Inizio
…..
Fine
Esercizio: A partire dalla classe Punto si estenda tale classe alla
classe PuntoSpazio. Si dia la rappresentazione UML e la pseudocodifica della nuova classe
34
Classe Puntospazio Eredita Punto
Inizio
Pubblico Z:Reale
/* terza coordinata*/
Punto
+X:Reale
+Y:Reale
+Punto()
+Punto(IN x1:Reale)
……
Pubblico PuntoSpazio(X1:Reale,Y1:Reale,Z1:Reale)
/* metodo costruttore crea un punto nello spazio*/
Inizio
X X1
Y Y1
Z  Z1
Fine
Pubblico Distanza(P:Punto):Reale
R:Reale
Inizio
RRadiceq((OggettoCorrente.X - P.X)2 +(OggettoCorrente.Y – P.Y)2
) +(OggettoCorrente.Z – Z)2 )
Ritorno(R)
Fine
PuntoSpazio
+Z:Reale
+PuntoSpazio()
+PuntoSpazio(IN X: Reale, IN Y :Reale, IN Z: Reale)
+Distanza(IN P:Punto): Reale
La classe PuntoSpazio eredita le coordinate di
X e Y dalla classe Punto
Il metodo distanza è ridefinito
N.B. Un attributo o un metodo definito protetto
è visibile all’interno della classe dove è stato
definito e in tutte le sue sottoclassi.
35
Per richiamare il metodo orginale della superclasse nella sottoclasse, si
usa la parola Super che consente di risalire nella gerarchia
Super.<NomeMetodo>
Classe Astratta: nella gerarchia delle classi la classe che si trova più in
alto è la più astratta e generale, rappresenta l’idea, il centro di
riferimento.
Non possono essere istanziate
La pseudo-codifica è la seguente
Astratta classe <NomeClasse>
Inizio
….
Fine
Esistono due tipi di ereditarietà:
• Singola Ogni classe può avere al più una superclasse ma più sottoclassi (Java)
• Multipla Ogni classe può avere più superclassi e più sottoclassi (C++)
36
Le gerarchie di oggetti
La relazione tra classi che abbiamo visto e che si esplica tramite la
generalizzazione cui corrispondeva il concetto do eredità, non è
l’unica relazione possibile. Esiste anche la:

Relazione di aggregazione:relazione tra oggetti, ogni oggetto si
può presentare come composizione di altri oggetti, Una classe
può contenere come attributi anche oggetti di altre classi.
Esempio:
Motocicletta1
Istanza di Motocicletta
“Contiene”
Motore1
Istanza di Motore
Telaio1
Istanza di Telaio
RuotaAnteriore1
Istanza di RuotaAnteriore
RuotaPosteriore1
Istanza di RuotaPosteriore
37
La relazione di contenuto tra oggetti prende il nome di aggregazione.
• Quando si passa dalle classi contenute alle classi contenitore si dice
che si mette in atto un processo di Astrazione per aggregazione
• Quando si passa dalle classi contenitore a quelle contenute si dice
che si mette in atto un processo di Astrazione per Scomposizione
Motocicletta
Processo di
Processo di
+Marca:Stringa
+Modello:Stringa
………
Aggregazione
Scomposizione
+AvviaMotore()
+InserisciAnnoImmatricolazione(D:Intero)
Molteplicità
Relazione di
Aggregazione
1
1
Motore
1
1
1
Telaio
1
RuotaAnteriore
1
1
RuotaPosteriore
38
Esercizio: Consideriamo la classe Triangolo, i suoi vertici sono oggetti di
classe Punto. Un triangolo è composto da tre vertici. La molteplicità della
relazione è 3. Ci sono tre oggetti punto in relazione con un solo triangolo
Vediamo il diagramma delle aggregazioni
Triangolo
-P1:Reale
-P2:Reale
-P3:Reale
+Triangolo(Pu1:Punto, Pu2:Punto, Pu3:Punto)
+Perimetro():Reale
$+Perimetro (IN T:Triangolo):Reale
Costruttore
Query
Query
1
3
Punto
+X:Reale
+Y:Reale
+Punto()
+Punto(IN x:Reale)
+Punto(IN x:Reale, IN Y:Reale):Reale
Distanza(IN P:Punto):Reale
$+Distanza (IN P1:Punto,IN P2:Punto):Reale
Costruttore
Costruttore
Costruttore
Query
Query
39
Attività 8
Verifica di fine unità delle conoscenze:Test V/F
tempo 20 minuti
V
1.
I metodi privati di una classe non fanno parte della sua interfaccia con
l’esterno
2.
I metodi pubblici non sono incapsulati nell’oggetto
3.
Non è possibile vedere dall’esterno l’implementazione di un metodo privato
4.
Una modifica ad una variabile di classe si ripercuote su tutte le istanze di
quella classe
5.
Una superclasse è più specializzata di una sottoclasse
6.
Un metodo astratto è un metodo con segnatura ma privo di implementazione
7.
E’ possibile definire un metodo completo in una classe astratta
8.
Information Hiding vuol dire nascondere l’implementazione dei metodi
9.
Si ha una eredità multipla quando una classe ha più sottoclassi
10.
La relazione di aggregazione è una relazione di ereditarietà
F
40
Verifica di fine unità delle competenze
tempo 1,30 ore

1. Crea una gerarchia di classi e rappresentala in modo grafico
per le seguenti classi: Rettangolo, Quadrato, Poligono,
Esagono,Cerchio, FigurePiane.

2. Elenca le possibili sottoclassi della classe edificio

3. Data la gerarchia dell’esercizio precedente fai degli esempi di




Metodi
Metodi
Metodi
Metodi
ereditari
ridefiniti
estesi
di classe
41