Esempi al calcolatore su: 1) Costruttori ed ereditarietà 2) Subtyping e Polimorfismo

Transcript

1 Esempi al calcolatore su: 1) Costruttori ed ereditarietà 2) Subtyping e Polimorfismo 1

2 Esempio 1: Costruttori ed ereditarietà Costruttori ed ereditarietà 2

3 Introduzione Java prevede due automatismi legati ai costruttori: Se una classe non ha costruttori viene creato automaticamente il costruttore di default (quello senza parametri) Se in un costruttore di una classe derivata non viene invocato il costruttore delle classe base, viene automaticamente inserita la chiamata a super() Questi due meccanismi sono molto comodi ma bisogna fare attenzione perché si possono creare situazioni di errore non facili da comprendere Sviluppiamo un esempio che ha lo scopo di chiarire questi aspetti Costruttori ed ereditarietà 3

4 Esempio 1 prima versione Counter con attributo val intero protected e metodi pubblici reset(), inc(), getvalue() con costruttore di default definito che inizializza a 1 l attribito val e costruttore con un parametro intero n che inizializza val a n (anche un po di stampe ) BiCounter estende Counter con un metodo pubblico dec() senza alcun costruttore Main con un metodo pubblico statico main() Definisce Counter c e lo crea Definisce BiCounter c1 e lo crea Costruttori ed ereditarietà 4

5 Prima versione public class Counter protected int val; public Counter() System.out.println("Counter: costruttore default!"); val = 1; public Counter(int v) System.out.println( "Counter:costruttore"); val = v; public void reset() val = 0; public void inc() val++; public int getvalue() return val; public class BiCounter extends Counter public void dec() val--; public class Main public static void main(string Args[]) Counter c = new Counter(); BiCounter c1 = new BiCounter(); Non definiamo un costruttore per BiCounter Costruttori ed ereditarietà 5

6 Risultato Creazione istanza di Counter Creazione istanza di BiCounter Il compilatore Java ha aggiunto un costruttore di defaul in BiCounter e ha inserito in esso una chiamata a super() Costruttori ed ereditarietà 6

7 Prima versione public class Counter protected int val; public Counter() System.out.println("Counter: costruttore default!"); val = 1; public Counter(int v) System.out.println( "Counter:costruttore"); val = v; public void reset() val = 0; public void inc() val++; public int getvalue() return val; public class BiCounter extends Counter public BiCounter() super(); public void dec() val--; public class Main public static void main(string Args[]) Counter c = new Counter(); BiCounter c1 = new BiCounter(); Non definiamo un costruttore per BiCounter Costruttori ed ereditarietà 7

8 Esempio 1 seconda versione Counter invariato BiCounter estende Counter con un metodo pubblico dec() (come prima) definisce un costruttore che inizializza val a 1 (e fa un po di stampe ) Main invariato Costruttori ed ereditarietà 8

9 Seconda versione public class Counter protected int val; public Counter() System.out.println("Counter: costruttore default!"); val = 1; public Counter(int v) System.out.println( "Counter:costruttore"); val = v; public void reset() val = 0; public void inc() val++; public int getvalue() return val; public class BiCounter extends Counter public BiCounter() System.out.println("Counter2: costruttore di default!"); val = 1; public void dec() val--; public class Main public static void main(string Args[]) Counter c = new Counter(); System.out.println(c.getValue()); BiCounter c1 = new BiCounter(); System.out.println(c1.getValue()); Costruttori ed ereditarietà 9

10 Risultato Creazione istanza di Counter Creazione istanza di BiCounter Il compilatore ha aggiunto una chiamata a super() nel costruttore di BiCounter Costruttori ed ereditarietà 10

11 Seconda versione public class Counter protected int val; public Counter() System.out.println("Counter: costruttore default!"); val = 1; public Counter(int v) System.out.println( "Counter:costruttore"); val = v; public void reset() val = 0; public void inc() val++; public int getvalue() return val; public class BiCounter extends Counter public BiCounter() super(); System.out.println("Counter2: costruttore di default!"); val = 1; public void dec() val--; public class Main public static void main(string Args[]) Counter c = new Counter(); System.out.println(c.getValue()); BiCounter c1 = new BiCounter(); System.out.println(c1.getValue()); Costruttori ed ereditarietà 11

12 Esempio 1 terza versione Counter con attributo val intero protected e metodi pubblici reset(), inc(), getvalue() senza costruttore di default definito, ma solo costruttore con un parametro intero n che inizializza val a n (anche un po di stampe ) BiCounter estende Counter con un metodo pubblico dec() costruttore di default definito che inizializza val a 1 Main invariato Costruttori ed ereditarietà 12

13 Terza versione public class Counter protected int val; Eliminiamo il costruttore di default public Counter(int v) System.out.println( "Counter:costruttore"); val = v; public void reset() val = 0; public void inc() val++; public int getvalue() return val; public class BiCounter extends Counter public BiCounter() System.out.println("Counter2: costruttore di default!"); val = 1; public void dec() val--; public class Main public static void main(string Args[]) Counter c = new Counter(); BiCounter c1 = new BiCounter(); Costruttori ed ereditarietà 13

14 Risultato C:\work\costruttori\Main.java:6: cannot resolve symbol symbol : constructor Counter () location: class Counter Counter c = new Counter(); ^ C:\work\costruttori\Counter.java:1: cannot resolve symbol symbol : constructor Counter () location: class Counter public class BiCounter extends Counter ^ 2 errors Process completed. Nella classe Counter, il costruttore di default non è stato inserito automaticamente, perché Counter ha almeno un costruttore (quello con parametro) Abbiamo quindi 2 errori di compilazione Costruttori ed ereditarietà 14

15 Una prima correzione Il primo errore è dovuto al fatto che in main() creiamo un istanza di Counter invocando il costruttore di default che non esiste più Modifichiamo quindi main() in modo che l istanza venga creata invocando il costruttore non di default public class Main public static void main(string Args[]) Counter c = new Counter(1); Counter c1 = new BiCounter(); Costruttori ed ereditarietà 15

16 Risultato C:\work\costruttori\Counter.java:1: cannot resolve symbol symbol : constructor Counter () location: class Counter public class BiCounter extends Counter ^ 1 error Ci resta ancora un errore dovuto al fatto che nel costruttore di BiCounter il compilatore ha inserito una chiamata a super() (costruttore di default della classe base) e questo non esiste in Counter Costruttori ed ereditarietà 16

17 Seconda correzione Inseriamo quindi nel costruttore di BiCounter una chiamata esplicita al costruttore effettivamente esistente di Counter (quello con il parametro intero) public class BiCounter extends Counter public BiCounter() System.out.println("Counter2: costruttore di default!"); super(0); public void dec() val--; Costruttori ed ereditarietà 17

18 Risultato C:\work\costruttori\Counter2.java:3: cannot resolve symbol symbol : constructor Counter () location: class Counter ^ C:\work\costruttori\Counter2.java:5: call to super must be first statement in constructor super(0); ^ 2 errors Otteniamo ancora degli errori di compilazione Infatti la chiamata a super(0) deve essere la prima istruzione del costruttore! Costruttori ed ereditarietà 18

19 Terza correzione Mettiamo la chiamata a super in prima posizione: public class BiCounter extends Counter public BiCounter() super(0); System.out.println( "Costruttore di default di Counter2"); public void dec() val--; public class Main public static void main(string Args[]) Counter c = new Counter(1); Counter c1 = new BiCounter(); c1.inc(); Costruttori ed ereditarietà 19

20 Risultato finale Adesso funziona tutto correttamente Creazione istanza di Counter Creazione istanza di BiCounter Costruttori ed ereditarietà 20

21 Ricapitolando La chiamata al costruttore del parent ( super() con o senza argomenti) deve essere la prima istruzione dei costruttori delle classi derivate Se non è specificato super() nei costruttori delle classi derivate, è invocato automaticamente il costruttore di default della classe base Il costruttore di default può essere generato automaticamente solo se nella classe base non è definito alcun costruttore Se non è presente un costruttore di default (definito dal programmatore o generato in automatico) di una classe, le classi derivate da questa devono esplicitamente usare la super( ) ed invocare il corretto costruttore (non di default) se questo c è Costruttori ed ereditarietà 21

22 Esempio 2: Subtyping 22

23 Subclassing e subtyping Fino ad ora abbiamo trattato l ereditarietà come strumento che consente il riuso flessibile di classi già esistenti mediante l aggiunta o la ridefinizione di metodi In realtà l ereditarietà ha una doppia natura, comprende cioè due diversi aspetti: Subclassing o ereditarietà di implementazione: è un meccanismo per il riuso che ci consente di estendere classi esistenti riusando il codice già scritto Subtyping o ereditarietà di interfaccia: è un meccanismo flessibile di compatibilità fra tipi Subtyping-polimorfismo

24 Variabili e tipi Nei linguaggi tradizionali, soprattutto in quelli legati al modello procedurale, esiste un sistema rigido di corrispondenza fra variabili e tipi Ogni variabile viene dichiarata come appartenente ad un tipo e, tranne poche eccezioni, non è possibile assegnargli valori di tipi diversi da quello di appartenenza Questo vincolo è molto importante perché consente al compilatore di effettuare tutta una serie di controlli che evitano i più comuni errori di programmazione Questi controlli vengono chiamati statici perché vengono effettuati una volta sola al momento della compilazione e non devono essere ripetuti continuamente durante l esecuzione del programma

25 Tipizzazione in Java In linea di principio questo vale anche per Java Infatti se scriviamo istruzioni come queste: int n; String s = 18 ; n = s; Otteniamo un errore di compilazione alla terza riga perché interi e stringhe sono cose completamente diverse Se vogliamo passare da un tipo all altro dobbiamo farlo esplicitamente n = Integer.intValue(s); Si dice quindi che Java è un linguaggio tipizzato (typed) perché il suo compilatore verifica staticamente che non ci siano violazioni al sistema dei tipi

26 Conversioni implicite In realtà anche in un linguaggio tipizzato vengono fatte conversioni implicite. Un esempio molto comune sono le conversioni che avvengono in un espressione matematica: int n = 5; double d; d = n * 2.5; Oppure nella concatenazione di stringhe: int n = 5; String s; s = Numero +n; Si tratta però di eccezioni, in generale in un linguaggio tipizzato il cambio di tipo deve essere esplicitato

27 Typecast Le conversioni implicite vengono fatte solo quando si ha la certezza che non si introducono errori o perdite di informazioni. Su quest ultimo aspetto in particolare Java è più restrittivo del C Per esempio se dichiariamo due variabili in questo modo int n = 7; long l = 14; double d = 7.5 Si può scrivere l = n; d = n; d = l; perché la conversione non comporta perdita di precisione Ma non è possibile scrivere: n = l; n = d; l = d; perché in tutti questi casi abbiamo potenzialmente perdita di informazione Dobbiamo esplicitare la conversione usando usando il typecast con la stessa sintassi del C n = (int)l; n = (int)d; l = (long)d; In questo modo il compilatore è sicuro che non si tratta di un errore, ma di una cosa voluta

28 Sottoclassi come sottotipi Un sistema di tipi come quello appena descritto rappresenta una sicurezza, ma può anche risultare eccessivamente rigido La programmazione orientata agli oggetti mette a disposizione un meccanismo più flessibile, ma altrettanto sicuro, basato sull ereditarietà In una sottoclasse noi possiamo solo aggiungere o ridefinire metodi, ma non eliminarne! Quindi un istanza di una sottoclasse è capace di fare tutto quello che sa fare la sua superclasse Ne consegue che possiamo utilizzare un istanza di una sottoclasse al posto di un istanza di una superclasse Si dice quindi che una sottoclasse è un sottotipo (subtyping)

29 Subtyping - 1 In pratica nei linguaggi orientati agli oggetti possiamo assegnare ad una variabile che ha come tipo una superclasse un istanza di una qualsiasi delle sue sottoclassi Per esempio possiamo scrivere: Counter c; c = new BiCounter(); In queste due istruzioni è racchiuso il concetto di subtyping E una forma estesa di conversione implicita: L insieme di metodi di BiCounter è un sovrainsieme di quello di Counter: BiCounter sa fare tutto quello che fa Counter Il compilatore ha quindi la certezza che non possiamo chiedere all istanza di BiCounter di fare qualcosa che non è in grado di fare

30 Ereditarietà di interfaccia e di implementazione L insieme dei metodi di una classe viene anche chiamato interfaccia della classe Possiamo quindi dire che l interfaccia di una sottoclasse comprende l interfaccia della sua superclasse (la eredita) E questo il senso del termine ereditarietà di interfaccia con cui spesso il subtyping viene designato In modo simile si parla di ereditarietà di implementazione per indicare il subclassing Infatti una classe derivata comprende l implementazione della classe base (a meno che non ridefinisca un metodo) Proviamo alcuni esempi.

31 Sostituibilità: Counter e BiCounter - 1 Riprendiamo le due classi Counter e BiCounter (con o senza costruttori ) public class Counter protected int val; public void reset() val = 0; public void inc() val++; public int getvalue() return val; public class BiCounter extends Counter public void dec() val--; Subtyping-polimorfismo

32 Sostituibilità: Counter e BiCounter - 2 Proviamo a scrivere un applicazione di esempio che usa Counter Definiamo nel main un oggetto Counter, creiamolo (new) e incrementiamolo 150 volte Ciclo for per i= usando il metodo inc() Poi stampiamone il valore (acquisendolo con il metodo getvalue()) Subtyping-polimorfismo

33 Sostituibilità: Counter e BiCounter - 2 public class Esempio public static void main(string[] args) int n; Counter c1; c1 = new Counter(); c1.reset(); for (int i=0; i<150; i++) c1.inc(); n = c1.getvalue(); System.out.println( Valore: +n); L applicazione scriverà a video: Valore: 150 Subtyping-polimorfismo

34 Sostituibilità: Counter e BiCounter - 3 Modifichiamo l esempio usando un istanza di BiCounter anziché una di Counter Definiamo il reference come Counter, ma creiamo l istanza come BiCounter nel main Poi stampiamone il valore Cosa stampa?

35 Sostituibilità: Counter e BiCounter - 3 Modifichiamo l esempio usando un istanza di BiCounter anziché una di Counter public class Esempio public static void main(string[] args) int n; Counter c1; c1 = new BiCounter(); // Era c1 = new Counter() c1.reset(); for (i=0;i<150;i++) c1.inc(); n = c1.getvalue(); System.out.println(n); Cosa stampa?

36 Sostituibilità: Counter e BiCounter - 3 Modifichiamo l esempio usando un istanza di BiCounter anziché una di Counter public class Esempio public static void main(string[] args) int n; Counter c1; c1 = new BiCounter(); // Era c1 = new Counter() c1.reset(); for (i=0;i<150;i++) c1.inc(); n = c1.getvalue(); System.out.println(n); Il programma funziona esattamente come prima scrivendo a video: Valore: 150

37 Subtyping Ogni oggetto istanza di BiCounter è un Counter Risponde agli stessi metodi di Counter (ereditarietà di interfaccia) Counter #val : int +inc() : void +reset() : void +getvalue() : int Link is-a, BiCounter is-a Counter BiCounter +dec() : void Ereditarietà

38 Ancora sul subtyping Riprendiamo l esempio di subtyping fra Counter e BiCounter Counter c; c = new BiCounter(); MAttenzione: anche se la variabile c fa riferimento ad un istanza di BiCounter è di tipo Counter e quindi possiamo fare con c solo quello che sa fare Counter Possiamo scrivere: c.inc(); Ma non: c.dec(); E il tipo della variabile, e non il tipo dell istanza, a determinare quello che possiamo fare! Subtyping-polimorfismo

39 Counter e BiCounter - 4 public class Esempio public static void main(string[] args) int n; Counter c1; c1 = new BiCounter(); // Era c1 = new Counter() c1.reset(); for (i=0;i<150;i++) c1.inc(); n = c1.getvalue(); System.out.println(n); BiCounter a= (BiCounter) c1; a.dec(); Casting esplicito, e assegnamento a un reference di tipo BiCounter per poter invocare anche i metodi di BiCounter

40 Overriding Se l ereditarietà consentisse solo l aggiunta di metodi non ci sarebbe molto altro da dire Sappiamo invece che è anche possibile la ridefinizione di un metodo esistente (overriding) Abbiamo visto che questo meccanismo aggiunge una notevole flessibilità ai meccanismi di riuso Ma oltre a ciò, la combinazione tra subtyping e overriding apre nuove prospettive ma anche qualche possibile fonte di confusione!

41 Sostituibilità: Counter e CentoCounter - 1 Riprendiamo ora in esame la classe CentoCounter che, come BiCounter è una sottoclasse di Counter In questo caso però in CentoCounter anziché aggiungere un metodo ne avevamo ridefinito uno: public class CentoCounter extends Counter public void inc() if (val<100) val++; Subtyping-polimorfismo

42 Sostituibilità: Counter e BiCounter - 3 Modifichiamo l esempio usando un istanza di CentoCounter anziché una di Counter Definiamo il reference come Counter, ma creiamo l istanza come CentoCounter nel main Poi stampiamone il valore Cosa stampa?

43 Sostituibilità: Counter e CentoCounter - 2 Sostituendo un istanza di Counter con una di CentoCounter nel nostro esempio: public class Esempio public static void main(string[] args) int n; Counter c1; c1 = new CentoCounter();// Era c1=new Counter() c1.reset(); for (int i=0;i<150;i++) c1.inc(); n = c1.getvalue(); System.out.println(n); Cosa stampa?

44 Sostituibilità: Counter e CentoCounter - 2 Sostituendo un istanza di Counter con una di CentoCounter nel nostro esempio: public class Esempio public static void main(string[] args) int n; Counter c1; c1 = new CentoCounter();// Era c1=new Counter() c1.reset(); for (int i=0;i<150;i++) c1.inc(); n = c1.getvalue(); System.out.println(n); Il programma scrive a video: Valore: 100 CentoCounter non è sostituibile con Counter!

45 Violazioni di sostituibilità Cosa è successo? Ridefinendo il metodo inc() in CentoCounter abbiamo fatto saltare la sostituibilità fra Counter e CentoCounter La classe derivata non è più sostituibile con la classe base Il pasticcio è nato dalla combinazione di due fattori: Abbiamo ridefinito un metodo (overriding) Nel ridefinirlo abbiamo ristretto il comportamento della classe derivata L errore è stato quello di usare l ereditarietà per restringere e non per estendere Non a caso la parola chiave che Java usa per indicare i legami di ereditarietà è extends

46 Riassumendo L ereditarietà va sempre usata per estendere Se si usa l ereditarietà per restringere si viola la sostituibilità tra superclasse e sottoclasse Questo è il motivo per cui quando si eredità non è consentito eliminare metodi Aggiungendo metodi non ci corrono rischi tuttavia: MAttenzione: quando si ridefinisce un metodo c è un potenziale rischio: bisogna sempre operare in modo da non restringere il comportamento del metodo originale