Polimorfismo dynamic dispatch

Polimorfismo dynamic dispatch Il tipo di una variabile non determina in modo univoco il tipo dell oggetto che la variabile riferisce Meccanismo già discusso per le interfacce Ogni variabile ha due tipi Statico: il tipo dichiarato Dinamico: il tipo dell oggetto a cui la variabile riferisce BankAccount abankaccount = new SavingsAccount(1000); // tipo statico: BankAccount // tipo dinamico: SavingsAccount Polimorfismo dynamic dispatch Il metodo invocato da un messaggio è determinato dal tipo dinamico della variabile, non dal tipo statico BankAccount anaccount = new CheckingAccount(); anaccount.deposit(1000); //chiama CheckingAccount.deposit() Polimorfismo dynamic dispatch Supponiamo di includere il metodo transfer in BankAccount 1

Polimorfismo dynamic dispatch Dynamic dispatch al lavoro public void transfer(double amount, BankAccount other) withdraw(amount); // this.withdraw(amount) other.deposit(amount); La selezione (dispatch) dei metodi withdraw() e deposit() da eseguire dipende dal tipo dinamico di this e di other, rispettivamente Polimorfismo dynamic dispatch public void transfer(double amount, BankAccount other) withdraw(amount); // this.withdraw(amount) other.deposit(amount); BankAccount sa = new SavingsAccount(10); BankAccount ca = new CheckingAccount(); sa.transfer(1000, ca); invoca SavingsAccount.withdraw() su sa CheckingAccount.deposit() su ca File BankAccount.java 01: /** 02: La classe radice della gerarchia 03: 04: */ 05: public class BankAccount 06: 07: /** 08: Constructs a bank account with a zero balance. 09: */ 10: public BankAccount() 11: 12: balance = 0; 13: 14: 15: /** 16: Constructs a bank account with a given balance. 17: @param initialbalance the initial balance 18: */ 2

File BankAccount.java 19: public BankAccount(double initialbalance) 20: 21: balance = initialbalance; 22: 23: 24: /** 25: Peposita un importo sul conto. 26: @param amount l importo da depositare 27: */ 28: public void deposit(double amount) 29: 30: balance = balance + amount; 31: 32: 33: /** 34: Prelievo di un importo dal conto. 35: @param amount l importo da prelevare 36: */ File BankAccount.java 37: public void withdraw(double amount) 38: 39: balance = balance - amount; 40: 41: 42: /** 43: Saldo corrente del conto. 44: @return il valore del campo balance 45: */ 46: public double getbalance() 47: 48: return balance; 49: 50: 51: /** 52: Trasferimento da questo conto ad un altro conto 53: @param amount l importo da trasferire 54: @param other il conto su cui trasferire 55: */ File BankAccount.java 56: public void transfer(double amount, BankAccount other) 57: 58: withdraw(amount); 59: other.deposit(amount); 60: 61: 62: private double balance; 63: 3

File CheckingAccount.java 01: /** 02: Un conto corrente, con commissioni sulle operazioni 03: */ 04: public class CheckingAccount extends BankAccount 05: 06: /** 07: Costruisce un conto con un saldo iniziale. 08: @param initialbalance il saldo iniziale 09: */ 10: public CheckingAccount(double initialbalance) 11: 12: // costruttore della superclasse 13: super(initialbalance); 14: 15: // inizializza i campi locali 16: transactioncount = 0; 17: 18: File CheckingAccount.java 19: public void deposit(double amount) 20: 21: transactioncount++; 22: // deposita invocando il metodo della superclasse 23: super.deposit(amount); 24: 25: 26: public void withdraw(double amount) 27: 28: transactioncount++; 29: // preleva invocando il metodo della superclasse 30: super.withdraw(amount); 31: 32: 33: /** 34: Deduce le commissioni accumulate e riazzera il 35: contatore delle transazioni. 36: */ File CheckingAccount.java 37: public void deductfees() 38: 39: if (transactioncount > FREE_TRANSACTIONS) 40: 41: double fees = TRANSACTION_FEE * 42: (transactioncount - FREE_TRANSACTIONS); 43: super.withdraw(fees); 44: 45: transactioncount = 0; 46: 47: 48: private int transactioncount; 49: 50: private static final int FREE_TRANSACTIONS = 3; 51: private static final double TRANSACTION_FEE = 2.0; 52: 4

File SavingsAccount.java 01: /** 02: Un libretto bancario con interessi fissi. 03: */ 04: public class SavingsAccount extends BankAccount 05: 06: /** 07: Costruisce un libretto con un tasso di interesse. 08: @param rate il tasso di interesse 09: */ 10: public SavingsAccount(double rate) 11: 12: interestrate = rate; 13: 14: 15: /** 16: Aggiunge gli interessi maturati al conto=. 17: */ File SavingsAccount.java 18: public void addinterest() 19: 20: double interest = getbalance() * interestrate / 100; 21: deposit(interest); 22: 23: 24: private double interestrate; 25: File AccountTester.java 01: /** 02: Test per la classe BankAccount e le sue sottoclassi 03: 04: */ 05: public class AccountTester 06: 07: public static void main(string[] args) 08: 09: SavingsAccount momssavings 10: = new SavingsAccount(0.5); 11: 12: CheckingAccount harryschecking 13: = new CheckingAccount(100); 14: 15: momssavings.deposit(10000); 16: 5

File AccountTester.java 17: momssavings.transfer(2000, harryschecking); 18: harryschecking.withdraw(1500); 19: harryschecking.withdraw(80); 20: 21: momssavings.transfer(1000, harryschecking); 22: harryschecking.withdraw(400); 23: 24: // test per le operazioni di fine mese 25: momssavings.addinterest(); 26: harryschecking.deductfees(); 27: 28: System.out.println("Mom's savings balance = $ 29: + momssavings.getbalance()); 30: 31: System.out.println("Harry's checking balance = $ 32: + harryschecking.getbalance()); 33: 34: Domande Supponiamo che a sia una variabile di tipo BankAccount con valore diverso da null. Cosa possiamo dire riguardo all oggetto riferito da a? Se a riferisce un CheckingAccount, quale è l effetto del messaggio a.transfer(1000, a)? (Super)classi abstract Nella definizione di una sottoclasse possiamo scegliere se ridefinire o meno i metodi della superclasse La interfaccia della superclasse può però rendere la ridefinizione dei metodi necessaria È il caso in cui nella superclasse si vuole fornire un metodo nell interfaccia, senza darne una implementazione Il metodo, e la superclasse sono abstract 6

(Super)classi abstract Classi abstract utili per descrivere l interfaccia comune di un insieme di classi definire alcuni aspetti dell implementazione (struttura e metodi) lasciandone non speficicati altri Un costrutto intermedio tra classi e interfacce (Super)classi abstract Esempio: potremmo ripensare alla gerarchia radicata in BankAccount, e decidere di strutturarla in modo che tutti i conti debbano avere un metodo deductfees() Simile alla situazione dei metodi deposit() e deposit() Ma per deductfees()non abbiamo una implementazione utile per le sottoclassi (Super)classi abstract Due possibilità: Definiamo un metodo con corpo vuoto Alternativa migliore: forziamo le sottoclassi a fornire una implementazione definendo il metodo, e la classe abstract public abstract class BankAccout... public abstract void deductfees();... 7

(Super)classi abstract Una classe che definisce (o eredita) un metodo abstract deve a sua volta essere dichiarata abstract Una sottoclasse può sovrascrivere un metodo abstract fornendo una implementazione Una classe abstract non può essere istanziata Questo non significa che non possa avere un costruttore Il costruttore sarà invocato dalle sottoclassi che forniscono implementazione ai metodi abstract Eventi del mouse MouseListener vs MouseAdapter abstract class MouseAdapter implements MouseListener // un metodo per ciascun mouse event su una componente public void mousepressed(mouseevent event) /* donothing */; public void mousereleased(mouseevent event)/* donothing */; public void mouseclicked(mouseevent event) /* donothing */; public void mouseentered(mouseevent event) /* donothing */; public void mouseexited(mouseevent event) /* donothing */; Eventi del mouse MouseAdapter è abstract e quindi non può essere istanziata direttamente, anche se tutti i suoi metodi sono concreti possiamo estenderla con un classe concreta class MyAdapter1 extends MouseAdapter /* inutile, ma compila e può essere istanziata class MyAdapter2 extends MouseAdapter /* gestisce solo gli eventi click */ public void MouseClicked... 8

Metodi e (sotto) classi final È possibile impedire la ridefinizione di un metodo in una sottoclasse, dichiarando il metodo final Oppure dichiarare non ridefinibili tutti i metodi della classe, definendo la classe stessa final Metodi e (sotto) classi final Due motivazioni Efficienza: metodi final hanno dispatch statico Sicurezza public class SecureAccount extends BankAccout public final boolean checkpassword(string pwd)... Controllo degli accessi Java ha quattro livelli di accessibilità per campi, metodi e classi interne. public accessibile dai metodi di qualunque classe private accessibile solo dai metodi della proria classe protected accessibile alle sottoclassi package accessibile da tutte le classi dello stesso package Il livello default, quando non specifichiamo alcun livello di accesso in modo eseplicito 9

Livelli di accesso raccomandati Variabili di istanza private. Eccezioni: public static per costanti (campi final) Esempio: System.out, accessibile a tutte le classi Campi di classi strettamente interconnesse all interno di un package considerate se non sia più opportuno utilizzare classi interne Livelli di accesso raccomandati Metodi: public, private protected può essere una opzione ragionevole in questo caso Classi e interfacce: public o package Alternativa all accesso package: classi interne In generale, per le classi interne utilizziamo le stesse prassi dei campi (mai public ) Esistono eccezioni: Ellipse2D.Double Attenzione ai default: omettere public o private implica accesso package Polimorfismo compile time Il compilatore verifica che esista un metodo da selezionare in risposta al messaggio Object anobject = new BankAccount(); anobject.deposit(1000); // Wrong! Meglio: verifica l esistenza del metodo, e decide il tipo del metodo da invocare tra le possibili versioni overloaded Il corpo del metodo, con il tipo selezionato, viene determinato a run time. 10

Overriding vs overloading Notare che esistono due fasi nella selezione del metodo da invocare: Fase statica: risoluzione dell overloading determina il tipo del metodo, in funzione del tipo statico degli argomenti presenti nel messaggio Fase dinamica: dispatch determina il corpo del metodo, in funzione del tipo dinamico del parametro implicito (ovvero, del destinatario del messaggio) Polimorfismo run time Dispatch articolato di quanto abbiamo visto Metodi dispatch dinamico, con le seguenti eccezioni: metodi private, chiamate via super Metodi di classe (static) dispatch è sempre statico Campi dispatch è sempre statico, sia per variabili di istanza, sia per variabili di classe (o static) Invocazione di metodi exp.m(a1,..., an) per definire precisamente l effetto della chiamata dobbiamo analizzare tre aspetti: selezione statica decide se è corretto invocare m( ) su exp, ovvero se esiste un metodo da invocare determina il tipo del metodo da invocare dispatch determina il corpo del metodo da invocare 11

Selezione statica exp.m(a1,..., an) Due fasi: 1. Determina il tipo di exp 2. Determina la firma T m(t1, Tn) del metodo da invocare in base al tipo degli argomenti a1,...,an In questa fase (statica) tipo = tipo statico Selezione Statica Fase 1 exp.m(a1,..., an) Determina il tipo statico S di exp: 1. exp = super: S è la superclasse della classe in cui l invocazione occorre: 2. exp = this: S è la classe in cui l invocazione occorre 3. in tutti gli altri casi: S è il tipo dichiarato per exp Selezione statica Fase 2 exp.m(a1,..., an) exp:s Determina la firma del metodo da invocare 1. calcola il tipo degli argomenti, a1:s1,... an:sn 2. seleziona in S il metodo T m(t1,...,tn) tale che Si <:Ti e m() è accessibile dal contesto di chiamata 3. se S non ha un metodo m() con le caratteristiche desiderate, ripeti il passo 2 sul supertipo di S (ognuno dei supertipi di S ), finché non trovi un metodo oppure esaurisci la gerarchia. 12

Selezione statica e overloading L algoritmo appena visto assume che ogni classe contenga al più una versione del metodo da invocare Che succede se esiste una classe contiene più di una versione? Che succede se una classe ed una superclasse contengono diverse versioni dello stesso metodo? Sono entrambi casi di overloading, e la selezione statica deve risolverlo Selezione statica Fase 2 rivista exp.m(a1,..., an) exp:s Determina la firma del metodo da invocare 1. calcola il tipo degli argomenti, a1:s1,... an:sn 2. determina il best match T m(t1,...,tn) per l invocazione m(a1:s1, an:sn), a partire da S Se trovi una sola firma ok, altrimenti errore Best Match exp.m(a1:s1,..., an:sn) exp:s 1. Determina l insieme dei metodi applicabili APP(S, m(s1,..., Sn)) = U1.m(T11,...,T1n),...,Uk.m(Tk1,...,Tkn) tali che, per ogni j in [1..k] S<:Uj(quindi: esamina S ed i supertipi di S) m(tj1,. Tjn) è definito in Uj ed è visibile nel punto della chiamata exp.m(a1,,an). Si <: Tji per ogni i in [1..n] 2. Se l insieme è vuoto fallisci 13

Best Match 3. Altrimenti, calcola l insieme dei metodi migliori BEST(S,m(a1:S1,,. an:sn)) rimuovi da APP(S, m(a1:s1,... an:sn)) ogni Up.m(Tp1,..., Tpn) tale che esiste un metodo migliore, ovvero un metodo Uq.m(Tq1,...,Tqn) tale che - Uq <:Up (è definito in una superclasse più vicina a S) - Tqi <: Tpi (ha tipi degli argomenti piu vicini agli Si) 4. Se BEST(S,m(a1:S1,,an:Sn)) contiene più di un metodo, fallisci. Altrimenti l unico metodo nell insieme e` il best match per la chiamata exp.m(a1,...,an) Best Match Esempi class A public void m(int i) System.out.println("A.m(int)"); class B extends A public void m(string s) System.out.println("B.m(String)"); class over public static void main(string[] APP(A, args) m(int)) = A.m(int) APP(B, m(string)) = B.m(String) // APP(A,m(int)) APP(B, m(int)) = = A.m(int) A.m(int) B b = new B(); A a = new B(); a.m(1) b.m( a string ) ; b.m(1); // APP(B,m(String))= B.m(String) // APP(B,m(int)) = A.m(int) Best Match Esempi class A public void m(int i) System.out.println("A.m(int)"); class B extends A public void m(string s) System.out.println("B.m(String)"); class over public static void main(string[] args) B b = new B(); APP(A, m(int)) = A.m(int) A a = new B(); a.m(1) // APP(A,m(int)) APP(B, m(string)) = A.m(int) B.m(String) b.m( a string ) ;// APP(B,m(String))= APP(A, = B.m(String) a = b; a.m( a string ); // APP(A,m(string))= 14

Best Match Esempi class A public void m(int i) System.out.println("A.m(int)"); class B extends A public void m(double f) System.out.println("B.m"); class over public static void main(string[] args) B b = new B(); A a = new B(); a.m(1); // APP(A,m(int)) = A.m(int) b.m(1.5); // APP(B,m(double))= B.m(double) b.m(1); // APP(B,m(int)) = A.m(int),B.m(double) // BEST(B.m(int)) = A.m(int),B.m(double) Best Match Esempi class A public void m(double g) System.out.println("A.m"); class B extends A public void m(int i) System.out.println("B.m"); class over public static void main(string[] args) B b = new B(); A a = new B(); a.m(1); // APP(A,m(int)) = A.m(double) b.m(1.5); // APP(B,m(double))= A.m(double) b.m(1); // APP(B,m(int)) = A.m(double),B.m(int) // BEST(B.m(int)) = B.m(int) Best Match Esempi class A public void m(int i, float f) /* just return */ public void m(float f, int i) /* just return */ class test public static void main(string[] args) A a = new A(); a.m(1, 1); // APP(A, m(int,int)) = A.m(int,float), A.m(float,int) // BEST(A,m(int,int)) = A.m(int,float), A.m(float,int) 15

Invocazione di metodi exp.m(a1,..., an) per definire precisamente l effetto della chiamata dobbiamo analizzare tre aspetti: selezione statica: determina la firma del metodo da invocare calcolo del best match dispatch dinamico: determina il corpo del metodo da invocare se il dispatch è statico esegui il corpo del metodo determinato dalla selezione statica altrimenti esegui il corpo del metodo con il tipo determinato dalla selezione statica che trovi a partire dal tipo dinamico di exp Esempio class A public void m(double d)system.out.println("a.m(double)"); public void m(int i) System.out.println( A.m(int)"); class B extends A public void m(double d)system.out.print( B.m(double) ); class over public static void main(string[] args) A a = new B(); a.m(1.5); // Selezione statica: BEST(A, m(double)) = A.m(double) // Dispatch: B ridefinisce m(double). Quindi esegui B.m(double) Esempio class A public void m(double d) System.out.println("A.m(double)"); public void m(int i) System.out.println( A.m(int)"); class B extends A public void m(double d)system.out.print( B.m(double) ); class over public static void main(string[] args) A a = new B(); a.m(1); // Selezione statica: BEST(A, m(int)) = A.m(int) // Dispatch: B non ridefinisce m(int). Quindi esegui A.m(int) 16

Esempio class A public void m(double d) System.out.println("A.m(double)"); public void m(int i) System.out.println( A.m(int)"); class B extends A public void m(double d)system.out.print( B.m(double) ); class over public static void main(string[] args) B b = new B(); b.m(1); // Selezione statica: BEST(A, m(int))=a.m(int),b.m(double) Metodi private : dispatch statico Essendo private, non sono accessibili alle sottoclassi. Quindi le sottoclassi non possono fare overriding di questi metodi Dispatch può essere deciso dal compilatore Metodi private : dispatch statico dispatch statico: A.sd() class A public String test() return this.sd() + ", " + this.dd(); private String sd() return "A.sd()"; public String dd() return "A.dd()"; class B extends A public String sd() return "B.sd()"; public String dd() return "B.dd()";... // new B().test() = A.sd(), B.dd() // new A().test() = A.sd(), A.dd() dispatch dinamico: risolto a run time 17

Chiamate via super: dispatch statico class A public String test() return dd(); public String dd() return "A.dd()"; class B extends A public String dd() return (super.dd() + ", " + "B.dd()");... // super.dd() invoca sempre A.dd() // new B().test() = A.dd(), B.dd() // new A().test() = A.dd() Campi: dispatch statico class C String str = "C"; public void m() System.out.println(str); class D extends C String str = "D"; public void n() System.out.println(str);... D d = new D(); d.m(); // C d.n(); // D System.out.println(d.str); // D C c = d; c.m(); // C ((D)c).n(); // D System.out.println(c.str); // C Object: la superclasse cosmica Tutte le classi definite senza una clausola extends esplicita estendono automaticamente la classe Object 18

Object: la superclasse cosmica I metodi più utili definiti da questa classe String tostring() boolean equals(object otherobject) Object clone() Spesso overridden nelle classi di sistema e/o nelle classi definite da utente tostring() Object.toString() restituisce una stringa ottenuta dalla concatenazione del nome della classe seguita dal codice hash dell oggetto su cui viene invocato. tostring() ridefinito in tutte le classi predefinite per fornire una rappresentazione degli oggetti come stringhe Rectangle box = new Rectangle(5, 10, 20, 30); String s = box.tostring(); // s = "java.awt.rectangle[x=5,y=10,width=20,height=30]" invocato automaticamente tutte le volte che concateniamo un oggetto con una stringa 19

tostring() Possiamo ottenere lo stesso effetto nelle classi user-defined, ridefinendo il metodo: public String tostring() return "BankAccount[balance=" + balance + "]"; In questo modo abbiamo: BankAccount momssavings = new BankAccount(5000); String s = momssavings.tostring(); // s = "BankAccount[balance=5000]" equals() nella classe Object coincide con il test == verifica se due riferimenti sono identici sovrascritto in tutte le classi predefinite per implementare un test di uguaglianza di stato Il medesimo effetto si ottiene per le classi user-defined, sempre mediante overriding La firma del metodo in Object: public boolean equals(object otherobject) equals() overriding Sovrascrivendo equals() manteniamo la firma che il metodo ha nella classe Object public class Coin... public boolean equals(object otherobject) Coin other = (Coin) otherobject; return name.equals(other.name) && value == other.value;... Notiamo cast per recuperare informazione sul parametro equals per confrontare campi riferimento Continua 20

equals() overriding public class Coin... public boolean equals(object otherobject) if (otherobject == null) return false; Coin other = (Coin) otherobject; return name.equals(other.name) && value == other.value;... Se otherobject non è un Coin, errore... Possiamo fare meglio! Continua equals() overriding Dato coin:coin,consideriamo la chiamata coin.equals(obj) public class Coin overloading public boolean equals(coin other) return name.equals(other.name) && value == other.value; overriding public boolean equals(object other) if (other == null) return false; if (other instanceof Coin) return equals((coin)other); return false;... cast forza l invocazione della versione overloaded equals() overriding Nelle sottoclassi stessa logica public class CollectibleCoin extends Coin public boolean equals(collectiblecoin other)... public boolean equals(object other) if (other == null) return false; if (other instanceof CollectibleCoin) return equals((collectiblecoin)other); return false;... 21

equals() overriding ma attenzione alla struttura ereditata! public boolean equals(collectiblecoin other) if (!super.equals(other)) return false; return year == other.year; private int year; Domanda NB: quale versione di equals nella classe Coin invoca la chiamata super.equals(object)? public boolean equals(collectiblecoin other) if (!super.equals(other)) return false; return year == other.year; private int year; Domanda Cosa dobbiamo aspettarci dalla chiamata x.equals(x)? Deve sempre restituire true? 22

Domanda È possibile implementare equals in termini di tostring? È ragionevole come idea? clone() Come ben sappiamo, l assegnamento tra due riferimenti crea due riferimenti che puntano allo stesso oggetto BankAccount account2 = account; clone() Talvolta è utile/necessario creare una copia dell intero oggetto, non del solo riferimento 23

Object.clone() Crea shallow copies (copie superficiali) Object.clone() Non ripete il cloning sistematicamente sui campi di tipo riferimento Dichiarato protected per proibirne l invocazioni su oggetti la cui classe non abbia ridefinito esplicitamente clone() con livello di accesso public Controlla che l oggetto da clonare implementi l interfaccia Cloneable La ridefinizione del metodo nelle sottoclassi richiede attenzione (vedi API) clone() overriding Una classe che ridefinisce clone() deve attenersi alla firma del metodo nella classe Object Object clone() L uso del metodo che ne deriva è: BankAccount cloned = (BankAccount) account.clone(); Necessario il cast perchè il metodo ha Object come tipo risultato 24