4 programmazione object-oriented interfacce ereditarietà ... · programmazione oo 2011-2012 g....

Programmazione OO 2011-2012 G. Bucci 1

4

Programmazione Object-OrientedInterfacce

Ereditarietà vs ComposizioneAlcuni Design Patterns

UNIVERSITA’ DI FIRENZEFacoltà di Ingegneria

Giacomo Bucci


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


Programmare verso l’implementazione

Cane c = new Cane();c.abbaia();

Animale

Cane GattoClient

Cane è una implementazione concreta di Animale


Programmare verso l’interfaccia

Animale a = new Cane();a.faIlVerso();

Il client sa che a è un Cane, ma lo usa in modo polimorfico


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


Meglio ancora• Assegnare l’oggetto concreto (l’implementazione) a

run-time


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


……segue


Animale

+faIlVerso()

Cane

+faIlVerso()

Gatto

+faIlVerso()

Client

Intermediario

+getAnimale()

E’ una Fabbrica


Simile al Design Pattern

Factory Method


……segue

Animale

+faIlVerso()

Cane

+faIlVerso()

Gatto

+faIlVerso()

Client

Intermediario

+getAnimale()


Il vero Factory Method (GoF)

Animale Client


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


Contenuto




• Esercitiamoci


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)



• 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



• 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


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)


Due professionisti


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


Progettano e modellano

Progettano in modo identico

Modellano in modo diverso


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?


L’essenza del problema

• Polimorfismo = interfaccia unica ma comportamenti specifici diversi

• Ereditarietà: modo diretto per ottenere il polimorfismo …. ma con qualche inconveniente!


..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)?


..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 ???


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


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


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

}


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");}

}


Il clientOperatore op = new Operatore2();Super sup = new A();sup.setOperatore(op);sup.operazione();

:::::::::

sup.setOperatore(new Operatore1());sup.operazione();


Esercizio

Rifarla usando per quanto possibile il concetto di interfaccia e fare il confronto con la soluzione fin qui illustrata (classi astratte)


Come diventa il ns studioE’ il pattern Strategy


Pattern Strategy (GoF)


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


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


..si espande


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


Contenuto




• Esercitiamoci


E ora una panineria !

Non ci basta. Si vuole poter aggiungere a qualunque dei tipi di base altri ingredienti (lattuga, pomodoro, mozzarella, capperi,…)


Un modo


Un altro modo (?!)

Terrificante !!!


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


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


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


E se provassimo questa?


Esempio


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;}

}


..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;}

}


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


Decorator


Pattern Decorator

Intent• Attach additional responsibilities to an object

dynamically. Decorators provide a flexiblealternative to subclassing for extendingfunctionality.

Also Known As• Wrapper


Confronto

Funzionalità estese dalle strategie

Funzionalità estese dai decoratori


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


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!


Contenuto




• Esercitiamoci


Un disegno• Un oggetto :Picture che contiene linee, testi,

figure e altri oggetti :Picture


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


Il pattern Composite


Tipico nella grafica-graphics


Pattern Composite

Intent• Compose objects into tree structures to

represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.


Contenuto




• Esercitiamoci


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


Iteratore

Aggregato

+addElement()+removeElement()

Iteratore

-indice

+first()+hasNext()+getNext()

Client

Disaccoppia la struttura dal suo

accesso

Istanziato passandogli l’oggetto

su cui deve agire


Il “design pattern” Iterator


Iterator

• IntentProvide a way to access the elements of anaggregate object sequentially withoutexposing its underlying representation.

• Also Known AsCursor


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


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() { .. }

}


...nel client

Aggregato a = new AggregatoConcreto();Iteratore i = a.createIterator();

Elemento e = i.first(); //il primo

e = i.getNext(); //il successivo

\\ecc


Più iteratori sullo stesso aggregato


…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();::::


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


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)


Esempio di usopublic abstract class Elemento {…}

Elemento è una qualunque classeQui è astratta perché presumibilmente si intende specializzarla in sottoclassi di elementi differenziati



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



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


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


Contenuto




• Esercitiamoci


Esercitiamoci• Costruire più versioni di questo sistema


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


Cilindro

-raggio: double-altezza: double



..del tutto equivalente

package solidi;

public interface Solido { public double getVolume();public double getSurface();}


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


Versione 1


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


Versione 2

Esattamente come per la versione 1


Versione 2

NOTA: Struttura è a tutti gli effetti un’interfaccia; definisce solo metodi che vengono implementati dalle strutture concrete.


Versione 3


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


Versione 3


Sul Sito • Sono riportati gli scr per tre progetti sotto Eclipse. • Per usarli basta definire tre progetti e copiarci i rispettivi sorgenti.

4 programmazione object-oriented interfacce ereditarietà ... · programmazione oo 2011-2012 g....

Documents