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

La logica della OOP opera sulla base degli stessi presupposti: 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

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

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 Possibili valori degli attributi Marca: Marca1, Marca2, Marca3 Modello: Strada, Enduro, Corsa Colore: Rosso, verde, bianco rappresentano lo stato Cilindrata: 125, 250, 500 StatoMotore: Vero (acceso), Falso (spento) MarciaInserita: Prima, Seconda, terza Metodi AvviaMotore SpegniMotore modificano lo stato Accelera CambiaMarcia èGuasta? èInRiserva? èAccesa? comunicano lo stato

Dichiarazione in pseudo-codifica della 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 */ Se (StatoMotore=Vero) Allora Scrivi(‘Il motore è già acceso’) Altrimenti StatoMotore  Vero Scrivi(‘Il motore è stato acceso’) FineSe Fine Rifornimento (B:Intero):Intero /* Metodo */ Serbatoio  Serbatoio + B Ritorno(Serbatoio) Fine /* Classe */ Esercizi proposti: Descrivere in pseudo-codifica le classi: Automobile,Triangolo, Cerchio

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 () Modificatore Rifornimento (IN B:Intero):Intero Modificatore MostraStato() Query Attributi Metodi

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

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()

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 ……………… 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

Compiono tutte le operazioni necessarie alla nascita dell’oggetto 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

Ampliamento della 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 */ Marca  mMarca Colore  mColore Cilindrata  mCilindrata Fine Motocicletta (mMarca:Stringa, mColore:Stringa, mCilindrata:Intero, mBenzina:Intero, mStatoMotore:booleano) Inizio /*Secondo costruttore */ Se mBenzina ≤ CapacitàMax Allora Serbatoio  mBenzina Altrimenti Scrivi (‘Troppa Benzina’) FineSe StatoMotore Falso AvviaMotore() /* Metodo */ ……. Rifornimento (B:Intero):Intero /* Metodo */ …… MostraStato () … . /Metodo Query */ Fine /* Classe */ 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

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

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 Moto2 Istanza di Motocicletta Colore’Giallo’ Marca’Marca2’ Cilindrata750 StatoMotoreFalso Serbatoio10 Moto2 Istanza di Motocicletta Colore’Giallo’ Marca’Marca2’ Cilindrata750 StatoMotoreFalso Serbatoio10 Nome Istanza Attributi e valori

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

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 Colore Marca Cilindrata StatoMotore Serbatoio Rifornimento(B: Intero) AvviaMotore() MostraStato() Moto2 Istanza di Motocicletta Colore Marca Cilindrata StatoMotore Serbatoio Rifornimento(B: Intero) AvviaMotore() ) Messaggio Moto2.Rifornimento(5) Metodi richiamabili dall’esterno

<NomeOggetto>.<NomeAttributo> 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

Riprendiamo la nostra classe Motocicletta e aggiungiamo due metodi uno Set() e uno Get() 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 */ 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 */ Se mBenzina ≤ CapacitàMax Allora Serbatoio  mBenzina Altrimenti Scrivi (‘Troppa Benzina’) FineSe StatoMotore Falso AvviaMotore() /* Metodo */ Se (StatoMotore=Vero) Scrivi(‘Il motore è già acceso’) StatoMotore  Vero Scrivi(‘Il motore è stato acceso’) SetSerbatoio(B:Intero) Inizio Se ((B+Serbatoio) < CapacitàMax ) Allora Serbatoio  Serbatoio + B Altrimenti Scrivi(‘Il carburante eccede la capacità massima’) FineSe Fine GetSerbatoio() Scrivi(‘Il livello di carburante è:’, Serbatoio) MostraStato () Scrivi(‘Questa motocicletta è una ‘, Marca’, ‘ ’, Cilindrata, ‘ ’, Colore) Scrivi(‘’Serbatoio=‘,Serbatoio, ‘litri di carburante’) Se (StatoMotore=Vero) Scrivi(‘Il motore ora è acceso’) Scrivi(‘ Il motore ora è spento’) Fine /*Classe*/

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

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() ……… Fine Fine /*Classe TestMotocicletta*/ Creiamo una istanza T1 della classe TestMotocicletta e invochiamiamo il suo metodo Main() TestMotocicletta T1  Nuovo TestMotocicletta() T1.Main()

Pseudo-codice relativo al Main() L’esecuzione delle due istruzioni sarà affidata al compilatore/interprete del linguaggio di programmazione usato. Pseudo-codice relativo al 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”. 1) Main() 2) Inizio /*Main*/ Motocicletta M Nuovo Motocicletta(‘Marca1’,’Rosso’,650,10) Scrivi(‘Chiamo metodo MostraStato()…’) M.MostraStato() Scrivi(‘-----------’) Scrivi(‘Avvio il Motore….’) M.AvviaMotore() Scrivi(‘Chiamo il metodo SetSerbatoio()…’) M.setSerbatoio(59 Scrivi(‘---------’) Scrivi(‘Chiamo il metodo MostraStato()….’) Scrivi(‘Avvio il motore…’) Fine /*Main*/

Attività 4 Verifica in itinere delle conoscenze: Test V/F Tempo 20 minuti 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

Verifica in itinere delle conoscenze: Quesiti a risposta aperta tempo 40 minuti 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?

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 segnatura di un metodo e gli attributi che precede Privato - Nasconde all’esterno la segnatura di un metodo e l’attributo che precede Sintassi: <ClausolaDiVisibilità><Nomemetodo>([<List.Par>]):[<TipoRitorno>] <ClausolaDiVisibilità><NomeAttributo>:<TipoAttributo>]

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

Applicazione delle regole di visibilità alla 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 */ ….. Fine Pubblico Motocicletta (mMarca:Stringa, mColore:Stringa, mCilindrata:Intero, mBenzina:Intero, mStatoMotore:booleano) Inizio /*Secondo costruttore */ ……. Pubblico AvviaMotore() /* Metodo */ Pubblico Set (B:Intero):Intero /* Metodo */ …… MostraStato () … . /Metodo Query */ Fine /* Classe */

Diagramma UML Motocicletta +Marca:Stringa +Colore:Stringa Attributi Pubblici +Cilindrata:Intero +StatoMotore:Booleano -Serbatoio:Intero -CapacitàMax:Intero Attributi Privati -CeckOlio:Booleano -Ceckfreni:Booleano +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

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() Costruttore +Punto(IN x1:Reale) Costruttore +Punto(IN x1:Reale, IN Y1:Reale):Reale Costruttore +Distanza (IN P:Punto):Reale Query

Pubblico X:Reale /* variabile istanza */ Pubblico Y:Reale Classe Punto Inizio Pubblico X:Reale /* variabile istanza */ Pubblico Y:Reale Pubblico Punto() /*Primo metodo costruttore crea un punto nell’origine*/ X 0 Y 0 Fine Pubblico Punto(X1:Reale) /*Secondo metodo costruttore crea un punto sull’asse X*/ X X1 Pubblico Punto(X1:Reale, Y1:Reale) /*Terzo costruttore crea un punto in un posto qualsiasi */ Y Y1 Pubblico Distanza(P:Punto):Reale R:Reale RRadiceq((OggettoCorrente.X - P.X)2 +(OggettoCorrente.Y – P.Y)2 ) /*Radiceq=radice quadrata */ Ritorno(R) Fine /*Classe*/ Se si vuole usare lo stesso nome di un attributo o di un metodo per una variabile locale o un parametro

Progettare con un diagramma UML e in Pseudo-codifica Una classe Libro Main() X1,Y1:Reale Inizio Punto P0 Nuovo Punto() /*Punto Origine degli assi*/ 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*/ 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

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

Definizione di metodo di classe 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

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)

Rappresentazione con un diagramma UML di una gerarchia di classe VeicoloAMotore +AvviaMotore() +MostraStato() Metodo ereditato Generalizzazione VeicoloA2Ruote Automobile Eredita Specializzazione Scooter +MostraStato() +SostegnoLaterale():Booleano Ciclomotore Motocicletta Metodo ridefinito Metodo esteso

Ereditare metodi e attributi dalla Superclasse 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 pseudo-codifica della nuova classe

Classe Puntospazio Eredita Punto Inizio Pubblico Z:Reale /* terza coordinata*/ Pubblico PuntoSpazio(X1:Reale,Y1:Reale,Z1:Reale) /* metodo costruttore crea un punto nello spazio*/ X X1 Y Y1 Z  Z1 Fine Pubblico Distanza(P:Punto):Reale R:Reale RRadiceq((OggettoCorrente.X - P.X)2 +(OggettoCorrente.Y – P.Y)2 ) +(OggettoCorrente.Z – Z)2 ) Ritorno(R) Punto +X:Reale +Y:Reale +Punto() +Punto(IN x1:Reale) …… La classe PuntoSpazio eredita le coordinate di X e Y dalla classe Punto Il metodo distanza è ridefinito PuntoSpazio +Z:Reale +PuntoSpazio() +PuntoSpazio(IN X: Reale, IN Y :Reale, IN Z: Reale) +Distanza(IN P:Punto): Reale N.B. Un attributo o un metodo definito protetto è visibile all’interno della classe dove è stato definito e in tutte le sue sottoclassi.

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++)

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 Motocicletta1 Istanza di Motocicletta Motocicletta1 Istanza di Motocicletta “Contiene” Motore1 Istanza di Motore Telaio1 Istanza di Telaio RuotaAnteriore1 Istanza di RuotaAnteriore RuotaPosteriore1 Istanza di RuotaPosteriore

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 +Marca:Stringa +Modello:Stringa ……… +AvviaMotore() +InserisciAnnoImmatricolazione(D:Intero) Processo di Scomposizione Processo di Aggregazione Molteplicità Relazione di Aggregazione 1 1 1 1 1 1 1 1 1 RuotaAnteriore RuotaPosteriore Motore Telaio

Vediamo il diagramma delle aggregazioni 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) Costruttore +Perimetro():Reale Query $+Perimetro (IN T:Triangolo):Reale Query 1 3 Punto +X:Reale +Y:Reale +Punto() Costruttore +Punto(IN x:Reale) Costruttore +Punto(IN x:Reale, IN Y:Reale):Reale Costruttore Distanza(IN P:Punto):Reale Query $+Distanza (IN P1:Punto,IN P2:Punto):Reale Query

Attività 8 Verifica di fine unità delle conoscenze:Test V/F tempo 20 minuti 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à

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 ereditari Metodi ridefiniti Metodi estesi Metodi di classe