esempio open closed

Open Closed T. software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification

Esempio

Una particolare classe semplice (Naturali, ovvero numeri interi positivi)

Esempio

Ipotizziamo alcune soluzioni

Esempio

Ipotizziamo una estensione (del dominio)

Esempio

Ipotizziamo una estensione (del dominio)
Quale soluzione tra quelle proposte è “Open Closed” (ovvero consente l'estensione senza necessitare di modifiche)?

Dominio?

gestisco denaro contante (quindi solo positivi)

@Pre("@value>=0") // dbc framework Contract4j public Natural(int value) { this.value=value; } public Natural(int value) { if (value<0) { throw new InitException("non negativo: "+value); } this.value=value; } oppure: Costruttore

Aspettative @Test public void zeroEqualsZero() { Natural zero = new Natural(0); Natural anotherZero = new Natural(0); Assert.assertEquals(zero,anotherZero); }

Soluzione 1 @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass () != o. getClass ()) return false; Natural natural = (Natural) o; if (value != natural.value) return false; return true; } @Override public int hashCode() { return value; }

Soluzione 2 @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Natural)) return false; Natural natural = (Natural) o; if (value != natural.value) return false; return true; } @Override public int hashCode() { return value; }

Aspettative @Test public void zeroEqualsZero() { Natural zero = new Natural(0); Natural anotherZero = new Natural(0); Assert.assertEquals(zero,anotherZero); } Soluzione 1. equals con getClass() OK Soluzione 2. equals con instanceof OK

Estensione

Valori negativi

“sì alle estensioni! no alle modifiche!” public class Relative extends Natural { @Pre // precondizione rilassata public Relative(int value) { this.value = value; } .... }

“sì alle estensioni! no alle modifiche!” public class Relative extends Natural { @Pre // precondizione rilassata public Relative(int value) { this.value = value; } .... } La precondizione è rilassata. Preconditions cannot be strengthened in a subtype. (Postconditions cannot be weakened in a subtype.)

Correlazioni-osservazioni

Natural super classe di Relative

Natural sotto insieme di Relative (o, che è lo stesso, è isomorfo ad un suo sottoinsieme)

Natural sotto insieme di Relative (o, che è quasi lo stesso, è isomorfo ad un suo sottoinsieme)
Morfismo : (astrazione di un processo che trasforma una struttura astratta in un'altra mantenendo alcune caratteristiche "strutturali" della prima (wikipedia))

Natural sotto insieme di Relative (o, che è quasi lo stesso, è isomorfo ad un suo sottoinsieme)
Morfismo : (astrazione di un processo che trasforma una struttura astratta in un'altra mantenendo alcune caratteristiche "strutturali" della prima (wikipedia))
“Is A” != “sottoClasse di” (ricordate “Quadrato-Rettangolo”?)

Concretamente @Test public void testMixEquals() throws Exception { Natural unoNat = new Natural(1); Relative unoRel = new Relative(1); Assert.assertEquals(unoNat,unoRel); } Soluzione 1. equals con getClass() fallisce Soluzione 2. equals con instanceof va a buon fine

Concretamente @Test public void testMixEquals() throws Exception { Natural unoNat = new Natural(1); Relative unoRel = new Relative(1); Assert.assertEquals(unoNat,unoRel); } Sto sostituendo all'1 di Nat, l'1 di Rel (Liskov?)

if S is a subtype of T, then objects of type T in a program may be replaced with objects of type S without altering any of the desirable properties of that program What is wanted here is something like the following substitution property: If for each object o1 of type S there is an object o2 of type T such that for all programs P defined in terms of T, the behavior of P is unchanged when o1 is substituted for o2 then S is a subtype of T. Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a subtype of T. L.S.P. Varie definizioni

Nuova estensione public class ColoredRelative extends Relative { public static String NEUTRO="neutro"; public static String GRIGIO="grigio"; public static String NERO="nero"; private static String DEFAULT=NEUTRO; protected String colore=DEFAULT; public ColoredRelative(int value) { super(value); } ...

Violazione transitività @Test public void testTransViolation() throws Exception { Relative due = new Relative(2); ColoredRelative dueNeuter = new ColoredRelative(2); ColoredRelative dueNero = new ColoredRelative(2,ColoredRelative.NERO); Assert.assertFalse(dueNero.equals(dueNeuter)); Assert.assertEquals(due,dueNeuter); Assert.assertEquals(due,dueNero); }

Soluzione 3

Equals...
http://www.angelikalanger.com/Articles/JavaSolutions/SecretsOfEquals/Equals.html

Conclusione

Un costruttore non vuoto protected
Equals “non standard” (a slices)

Evoluzione su (L.S.P)

Sostituibilità come “uguale comportamento” (e niente questioni di “equals”)
Distinzione tra metodi osservativi e metodi modificativi (tramite annotations)
Sollecitare l'oggetto della classe padre sui suoi metodi che ne modificano lo stato
Verificare che la stessa sollecitazione su oggetti di sottoclasse verifichi lo stesso comportamento “visibile” (observers)

Evoluzione (equals)

Equivalenza (uguaglianza) cross-classing in senso più esteso (esempio: tra implementazioni differenti ma “uguali” di numeri complessi: forma polare e forma cartesiana)

nz

Links

www.objectmentor.com/resources/articles/ocp.pdf
http://www.artima.com/weblogs/viewpost.jsp?thread=4744
http://www.artima.com/intv/bloch17.html
http://www.objectmentor.com/resources/articles/lsp.pdf
http://www.angelikalanger.com/Articles/JavaSolutions/SecretsOfEquals/Equals-2.html