4 programmazione object-oriented interfacce ereditarietà ... · programmazione oo 2011-2012 g....
Post on 24-May-2018
218 Views
Preview:
TRANSCRIPT
Programmazione OO 2011-2012 G. Bucci 1
4
Programmazione Object-OrientedInterfacce
Ereditarietà vs ComposizioneAlcuni Design Patterns
UNIVERSITA’ DI FIRENZEFacoltà di Ingegneria
Giacomo Bucci
Programmazione OO 2011-2012 G. Bucci 2
Contenuto
• Programmare verso l’interfaccia• Ereditarietà e/o composizione
• Il pattern Strategy• Il pattern Decorator
• Altri Design Patterns• Il pattern Composite• Il pattern Iterator
• Esercitiamoci
Programmazione OO 2011-2012 G. Bucci 3
Programmare verso l’implementazione
Cane c = new Cane();c.abbaia();
Animale
Cane GattoClient
Cane è una implementazione concreta di Animale
Programmazione OO 2011-2012 G. Bucci 4
Programmare verso l’interfaccia
Animale a = new Cane();a.faIlVerso();
Il client sa che a è un Cane, ma lo usa in modo polimorfico
Programmazione OO 2011-2012 G. Bucci 5
Meglio ancora• Assegnare l’oggetto concreto (l’implementazione) a
run-time
Intermediario inter = new Intermediario();Animale a = inter.getAnimale();a.faIlVerso();
Animale
+faIlVerso()
Cane
+faIlVerso()
Gatto
+faIlVerso()
Client
Intermediario
+getAnimale()
Il client non sa che tipo di animale è a, sa solo che a sa fare il suo verso
Programmazione OO 2011-2012 G. Bucci 6
Meglio ancora• Assegnare l’oggetto concreto (l’implementazione) a
run-time
Intermediario inter = new Intermediario();Animale a = inter.getAnimale();a.faIlVerso();
Animale
+faIlVerso()
Cane
+faIlVerso()
Gatto
+faIlVerso()
Client
Intermediario
+getAnimale()
L’intermediaro deve sapere quale oggetto istanziare (eventualmente attraverso un parametro)
Il client non sa che tipo di animale è a, sa solo che a sa fare il suo verso
Programmazione OO 2011-2012 G. Bucci 7
……segue
Intermediario inter = new Intermediario();Animale a = inter.getAnimale();a.faIlVerso();
Animale
+faIlVerso()
Cane
+faIlVerso()
Gatto
+faIlVerso()
Client
Intermediario
+getAnimale()
E’ una Fabbrica
Programmazione OO 2011-2012 G. Bucci 8
Simile al Design Pattern
Factory Method
Intermediario inter = new Intermediario();Animale a = inter.getAnimale();a.faIlVerso();
……segue
Animale
+faIlVerso()
Cane
+faIlVerso()
Gatto
+faIlVerso()
Client
Intermediario
+getAnimale()
Programmazione OO 2011-2012 G. Bucci 9
Il vero Factory Method (GoF)
Animale Client
Programmazione OO 2011-2012 G. Bucci 10
Factory method• Intent
Define an interface for creating an object, but letsubclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
• Also Known AsVirtual Constructor
In generale si parla di fabbrichequando si vuole confinare da qualche parte i dettagli della creazione di oggetti
Programmazione OO 2011-2012 G. Bucci 11
Contenuto
• Programmare verso l’interfaccia• Ereditarietà e/o composizione
• Il pattern Strategy• Il pattern Decorator
• Altri Design Patterns• Il pattern Composite• Il pattern Iterator
• Esercitiamoci
Programmazione OO 2011-2012 G. Bucci 12
Ereditarietà o composizione?
• L’ereditarietà è statica (definita al tempo di compilazione)
• L’ereditarietà è facile da usare è parte del linguaggio; evita la riscrittura di parti comuni
• L’ereditarietà viola il principio dell’incapsulameto le classi figlie vedono quello che c’è nella classe padre (una modifica nella classe padre può avere conseguenze sulle classi figlio)
Programmazione OO 2011-2012 G. Bucci 13
Ereditarietà o composizione?
• La composizione è dinamica (attraverso i riferimenti acquisiti al tempo di esecuzione)
• La composizione permette la sostituzione di un oggetto con un altro al tempo di esecuzione
• La composizione presuppone che gli oggetti rispettino le interfacce il principio di incapsulamento non viene mai violato
• Programmare verso l’interfaccia
Programmazione OO 2011-2012 G. Bucci 14
Ereditarietà o composizione?
• Favorire la composizione di oggetti rispetto all’ereditarietà
• La composizione aiuta a tenere ogni classe ben focalizzata e coesa
• Evita la costruzione di gerarchie classi mostruose e ingestibili, ma porta a un aumento del numero degli oggetti
Programmazione OO 2011-2012 G. Bucci 15
Problema• Modellare uno studio professionale
• Differenti tipi di professionisti che svolgono• attività comuni in modo del tutto identico (mangiare)• attività comuni ma in modo differenziato caratteristico di
ciascun professionista (display)
Programmazione OO 2011-2012 G. Bucci 16
Due professionisti
Programmazione OO 2011-2012 G. Bucci 17
Facciamoli lavorare
• Supponiamo che debbano progettare e modellare. Ma come?• Ingegneri e Architetti progettano e modellano allo
stesso modo• Due metodi concreti in Professionista
• Ingegneri e Architetti progettano e modellano in modi diversi
• Due metodi astratti in Professionista e reimplementati
Programmazione OO 2011-2012 G. Bucci 18
Progettano e modellano
Progettano in modo identico
Modellano in modo diverso
Programmazione OO 2011-2012 G. Bucci 19
Estendiamo un po’
• Progettazione • Meccanica• Civile
• Modellazione• Urbanistica• Strutturale
L’ingegnere può fare progettazione meccanica o progettazione civile.
Che facciamo? Deriviamo da Ingegnere due diversi tipi di ingegneri e ridefiniamo la progettazione?
Programmazione OO 2011-2012 G. Bucci 20
L’essenza del problema
• Polimorfismo = interfaccia unica ma comportamenti specifici diversi
• Ereditarietà: modo diretto per ottenere il polimorfismo …. ma con qualche inconveniente!
Programmazione OO 2011-2012 G. Bucci 21
..essenza del problemaPossono venir fuori gerarchie mostruose
L’eredità è rigida: il comportamento è fissato al tempo di compilazione. E’ quello e basta!
E se volessimo che operazione() fosse fatta in modi diversi, in tempi diversi (scegliere il comportamento a run-time)?
Programmazione OO 2011-2012 G. Bucci 22
..essenza del problema
Se provassimo a separare le parti soggette a variare in modo che gli effetti delle variazioni non si propaghino anche alle parti che possono restare fisse ???
Programmazione OO 2011-2012 G. Bucci 23
Favorire la composizione!
•Super (cioè A) delega l’Operatore all’esecuzione dell’operazione
• L’operazione viene fatta secondo operatore concreto istanziato
• Al tempo di esecuzione di può sostituire un operatore con un altro
Separare e Delegare Come A2Come A1
Programmazione OO 2011-2012 G. Bucci 24
Favorire la composizione!
1. Istanziazione di Operatore1 o Operatore2 a seconda di come deve essere fatta l’operazione
2. Istanziazione di A
3. Passaggio dell’Operatore a A; uso di A
4. Eventuale passaggio di un nuovo Operatore ad A; uso di A
Programmazione OO 2011-2012 G. Bucci 25
Le due astrattepublic abstract class Super {
protected Operatore operatore;
public void setOperatore(Operatore operatore){this.operatore= operatore;
}public void operazione(){
operatore.operazione();}
}
public abstract class Operatore {public abstract void operazione();
}
Programmazione OO 2011-2012 G. Bucci 26
Le concretepublic class A extends Super { }
public class Operatore1 extends Operatore {public void operazione() {
System.out.println(“Operatore 1");}
}
public class Operatore2 extends Operatore {public void operazione() {
System.out.println("Operatore 2");}
}
Programmazione OO 2011-2012 G. Bucci 27
Il clientOperatore op = new Operatore2();Super sup = new A();sup.setOperatore(op);sup.operazione();
:::::::::
sup.setOperatore(new Operatore1());sup.operazione();
Programmazione OO 2011-2012 G. Bucci 28
Esercizio
Rifarla usando per quanto possibile il concetto di interfaccia e fare il confronto con la soluzione fin qui illustrata (classi astratte)
Programmazione OO 2011-2012 G. Bucci 29
Come diventa il ns studioE’ il pattern Strategy
Programmazione OO 2011-2012 G. Bucci 30
Pattern Strategy (GoF)
Programmazione OO 2011-2012 G. Bucci 31
Strategy (GoF)
• IntentDefine a family of algorithms, encapsulateeach one, and make them interchangeable. Strategy lets the algorithm varyindependently from clients that use it.
• Also Known AsPolicy
Programmazione OO 2011-2012 G. Bucci 32
Lo studio si espande…• Entra in studio un economista
• Fa modelli economici, ma non progettaLa relativa funzionalità progetta() deve essere vuota
• Aggiunge un professionalità in più: amministrareSe vogliamo mantenere la struttura uniforme occorre aggiungere amministrare() all’interfaccia del professionista e renderla vuota per quelli che non la usano
Programmazione OO 2011-2012 G. Bucci 33
..si espande
Programmazione OO 2011-2012 G. Bucci 34
Lezione imparata
• Delegare• Incapsulare a parte ciò che è soggetto a
variare• Favorire la composizione rispetto
all’ereditarietà• E, come sempre …, programmare verso
l’interfaccia non verso l’implementazione
Programmazione OO 2011-2012 G. Bucci 35
Contenuto
• Programmare verso l’interfaccia• Ereditarietà e/o composizione
• Il pattern Strategy• Il pattern Decorator
• Altri Design Patterns• Il pattern Composite• Il pattern Iterator
• Esercitiamoci
Programmazione OO 2011-2012 G. Bucci 36
E ora una panineria !
Non ci basta. Si vuole poter aggiungere a qualunque dei tipi di base altri ingredienti (lattuga, pomodoro, mozzarella, capperi,…)
Programmazione OO 2011-2012 G. Bucci 37
Un modo
Programmazione OO 2011-2012 G. Bucci 38
Un altro modo (?!)
Terrificante !!!
Programmazione OO 2011-2012 G. Bucci 39
Un po’ meglio
Sandwich panino = new SandwichCrudo();panino.addIngrediente(pomodoro); // aggiunge a ingredientipanino.addIngrediente(xx);....double prezzo = panino.getCost();for (ingrediente i : ingredienti) prezzo = prezzo +i.getCost();
Programmazione OO 2011-2012 G. Bucci 40
Un po’ meglio
nel clientSandwich panino = new SandwichCrudo();panino.addIngrediente(pomodoro);panino.addIngrediente(xx);....double prezzo = panino.getCost();for (ingrediente i : ingredienti) prezzo = prezzo +i.getCost();
Brutto: ingredienti èmeglio sia privato !!
Programmazione OO 2011-2012 G. Bucci 41
Sul codice precedente• Rendere ingredienti private entro sandwich
(evitare le variabili globali!!) e prevedere un metodo per ottenere gli ingredienti aggiunti a un panino.
Nel client Sandwich panino = new SandwichCrudo();panino.addIngrediente(pomodoro);panino.addIngrediente(xx);
....ArrayList<Ingrediente> ingredienti = panino.getIngredienti();double prezzo = panino.getCost();for (Ingrediente i : ingredienti) prezzo = prezzo +i.getCost();
Programmazione OO 2011-2012 G. Bucci 42
E se provassimo questa?
Programmazione OO 2011-2012 G. Bucci 43
Esempio
Programmazione OO 2011-2012 G. Bucci 44
Il codicepublic abstract class Sandwich {
protected double cost;public abstract double getCost();
}
public class SandwichCrudo extends Sandwich {public SandwichCrudo(){cost = 25;}public double getCost(){return cost;}
}
Programmazione OO 2011-2012 G. Bucci 45
..il codicepublic abstract class IngrDecoratore extends Sandwich {
protected Sandwich component;}
public class Lattuga extends IngrDecoratore {public Lattuga (Sandwich component){this.cost = 2;this.component = component;}public double getCost(){
return component.getCost()+cost;}
}
Programmazione OO 2011-2012 G. Bucci 46
Il clientSandwich panino = new SandwichCrudo();
//panino di basepanino = new Pomodoro(panino);
// panino + pomodoropanino = new Lattuga(panino);
// panino + pomodoro + lattugapanino = new Capperi(panino); // panino + pomodoro + lattuga + //capperi
double prezzo = panino.getCost();
Programmazione OO 2011-2012 G. Bucci 47
Decorator
Programmazione OO 2011-2012 G. Bucci 48
Pattern Decorator
Intent• Attach additional responsibilities to an object
dynamically. Decorators provide a flexiblealternative to subclassing for extendingfunctionality.
Also Known As• Wrapper
Programmazione OO 2011-2012 G. Bucci 49
Confronto
Funzionalità estese dalle strategie
Funzionalità estese dai decoratori
Programmazione OO 2011-2012 G. Bucci 50
Confronto
Il componente sa delle possibili estensioni: spetta a lui tenere il riferimento alla strategia
Un decoratore aggiunge roba dall’esterno: il componente non sa nulla del decoratore
Programmazione OO 2011-2012 G. Bucci 51
Confronto
Il componente sa che delle possibili estensioni: spetta a lui tenere il riferimento alla strategia
Un decoratore aggiunge roba dall’esterno: il componente non sa nulla del decoratore
E’ bene che la classe Component sia leggera!
Programmazione OO 2011-2012 G. Bucci 52
Contenuto
• Programmare verso l’interfaccia• Ereditarietà e/o composizione
• Il pattern Strategy• Il pattern Decorator
• Altri Design Patterns• Il pattern Composite• Il pattern Iterator
• Esercitiamoci
Programmazione OO 2011-2012 G. Bucci 53
Un disegno• Un oggetto :Picture che contiene linee, testi,
figure e altri oggetti :Picture
Programmazione OO 2011-2012 G. Bucci 54
Lo schema precedente
• E’ una relazione tra parti e composizioni di parti
• E’ organizzato come una gerarchia
• Ci si pone il problema di fare in modo che le singole parti o le composizioni possano essere trattate in modo uniforme
Programmazione OO 2011-2012 G. Bucci 55
Il pattern Composite
Programmazione OO 2011-2012 G. Bucci 56
Tipico nella grafica-graphics
Programmazione OO 2011-2012 G. Bucci 57
Pattern Composite
Intent• Compose objects into tree structures to
represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.
Programmazione OO 2011-2012 G. Bucci 58
Contenuto
• Programmare verso l’interfaccia• Ereditarietà e/o composizione
• Il pattern Strategy• Il pattern Decorator
• Altri Design Patterns• Il pattern Composite• Il pattern Iterator
• Esercitiamoci
Programmazione OO 2011-2012 G. Bucci 59
Iteratori
• Capita di aver a che fare con strutture dati complesse (liste, code, ecc. )
• E’ buona norma accedere a queste strutture senza esporre la loro organizzazione interna
• A volte è necessario percorrere la struttura in modi diversi, senza per questo caricare l'interfaccia della struttura con un numero eccessivo di metodi
• Un iteratore è un oggetto usato per percorrere la struttura in modo sequenziale• Corrisponde al concetto di cursore
Programmazione OO 2011-2012 G. Bucci 60
Iteratore
Aggregato
+addElement()+removeElement()
Iteratore
-indice
+first()+hasNext()+getNext()
Client
Disaccoppia la struttura dal suo
accesso
Istanziato passandogli l’oggetto
su cui deve agire
Programmazione OO 2011-2012 G. Bucci 61
Il “design pattern” Iterator
Programmazione OO 2011-2012 G. Bucci 62
Iterator
• IntentProvide a way to access the elements of anaggregate object sequentially withoutexposing its underlying representation.
• Also Known AsCursor
Programmazione OO 2011-2012 G. Bucci 63
aggregatoabstract class Aggregato {public abstract Iteratore createIterator();}
class AggregatoConcreto extends Aggregato {public Iteratore createIterator() {
Iteratore i = new IteratoreConcreto(this);return i;}
}NB: gli aggregati sono aggregati
della classe Elemento
Passa se stesso, cioè l’aggregato
Programmazione OO 2011-2012 G. Bucci 64
Iteratore (casareccio)abstract class Iteratore {
public abstract Elemento first();public abstract boolean hasNext();public abstract Elemento getNext();
}
class IteratoreConcreto extends Iteratore {private Aggregato a;public IteratoreConcreto(Aggregato a){
this.a= a;}public Elemento first() { .. }public Elemento getNext() { .. }public boolean hasNext() { .. }
}
Programmazione OO 2011-2012 G. Bucci 65
...nel client
Aggregato a = new AggregatoConcreto();Iteratore i = a.createIterator();
Elemento e = i.first(); //il primo
e = i.getNext(); //il successivo
\\ecc
Programmazione OO 2011-2012 G. Bucci 66
Più iteratori sullo stesso aggregato
Programmazione OO 2011-2012 G. Bucci 67
…più iteratori sullo stesso…
Aggregato a = new AggregatoConcreto();Iteratore i1 = a.createIterator(1); Iteratore i2 = a.createIterator(2); :::: i1.first();i1.getNext();:::::i2.first();i2.getNext();::::
Programmazione OO 2011-2012 G. Bucci 68
Iteratore java• E’ un’Interfaccia:• Comune a tutte le Collection, cioè a tutte le classi che
implementano l’interfaccia Collection• A sua volta Collection estende l’interfaccia Iterable
Il metodo next()throws
Programmazione OO 2011-2012 G. Bucci 69
Interface Collection
• Esempi di classi che la implementano• AbstractCollection, AbstractList, …., ArrayList, …., Stack,
…Vector• Tutte presentano il metodo iterator() che restituisce
l’iteratore sugli elementi della collection
(sarà meglio vedere la documentazione Java)
Programmazione OO 2011-2012 G. Bucci 70
Esempio di usopublic abstract class Elemento {…}
Elemento è una qualunque classeQui è astratta perché presumibilmente si intende specializzarla in sottoclassi di elementi differenziati
Programmazione OO 2011-2012 G. Bucci 71
Esempio di usopublic abstract class Elemento {…}
public abstract class Aggregato{protected AbstractCollection<Elemento> elementi;….}
Anche Aggregato è stata fatta astratta => andrà specializzata
elementi è una Collezione astratta che verrà precisata nella classe derivata da Aggregato, ad esempio come ArrayList, Stack, Vector….
Programmazione OO 2011-2012 G. Bucci 72
Esempio di usopublic abstract class Elemento {…}
public abstract class Aggregato{protected AbstractCollection<Elemento> elementi;….}
Nel client: Iterator<Elemento> it = elementi.iterator();while (it.hasNext()){
it.next().metodoDiElemento();
it è l’iteratore sull’AbstractCollection elementi
•it.next è l’Elemento correnteIl ciclo itera il metodo di Elemento su tutti gli individui in elementi
Programmazione OO 2011-2012 G. Bucci 73
...Attenzione!
• Il nostro iteratore ha first()• Presumibilmente first() riporta il primo elemento e si
posiziona sul secondo (se esiste)• Presuppone che (almeno) un elemento ci sia obbligatoriamente• Oppure restituisce null, se non c’è nessun elemento
• L’iteratore di Java si porta sul primo elemento quando viene creato
• Non presuppone che ci sia almeno un elemento nell’aggregato
Programmazione OO 2011-2012 G. Bucci 74
Contenuto
• Programmare verso l’interfaccia• Ereditarietà e/o composizione
• Il pattern Strategy• Il pattern Decorator
• Altri Design Patterns• Il pattern Composite• Il pattern Iterator
• Esercitiamoci
Programmazione OO 2011-2012 G. Bucci 75
Esercitiamoci• Costruire più versioni di questo sistema
Programmazione OO 2011-2012 G. Bucci 76
Un package per i solidi
package solidi;
public abstract class Solido { public abstract double getVolume();public abstract double getSurface();}
Solido
+getVolume(): double+getSurface(): double
Cubo
-Lunghezza: double
+getVolume(): double+getSurface(): double
Cilindro
-raggio: double-altezza: double
+getVolume(): double+getSurface(): double
Programmazione OO 2011-2012 G. Bucci 77
..del tutto equivalente
package solidi;
public interface Solido { public double getVolume();public double getSurface();}
Programmazione OO 2011-2012 G. Bucci 78
Prima di andare avanti• Si costruisca un aggregato (Struttura) di solidi e la si
riempia a caso di cubi e cilindri• Si costriscano questi iteratori (casarecci)
• Uno che preleva il prossimo solido indifferenziato• Uno che preleva solo cubi• Uno che preleva solo cilindri
(ovviamente dovranno essere estratti secondo l’ordine con cui sono stati immessi)
• Suggerimento: fare un iteratore generale e decorarlo in modo da ottenere gli altri due
• Si ripeta l’esercizio usando l’iteratore di Java
Programmazione OO 2011-2012 G. Bucci 79
Versione 1
Programmazione OO 2011-2012 G. Bucci 80
Versione 1
Attenzione: qui che Struttura sia astratta non serve praticamente a nulla. Poteva essere concreta e definire attributi e metodi
Ha senso in previsione di una eventuale estensione con più possibili strutture complete
Solido[] solidi
Solido[] solidi
Programmazione OO 2011-2012 G. Bucci 81
Versione 2
Esattamente come per la versione 1
Programmazione OO 2011-2012 G. Bucci 82
Versione 2
NOTA: Struttura è a tutti gli effetti un’interfaccia; definisce solo metodi che vengono implementati dalle strutture concrete.
Programmazione OO 2011-2012 G. Bucci 83
Versione 3
Programmazione OO 2011-2012 G. Bucci 84
Versione 3
•Struttura è astratta perchédefinisce al suo interno una struttura astratta
•I metodi però sono concreti in quanto possono essere definiti sulla struttura astratta•Le strutture concrete si differenziano attraverso le collection concrete che contengono
Programmazione OO 2011-2012 G. Bucci 85
Versione 3
Programmazione OO 2011-2012 G. Bucci 86
Sul Sito • Sono riportati gli scr per tre progetti sotto Eclipse. • Per usarli basta definire tre progetti e copiarci i rispettivi sorgenti.
top related