Programmazione ad oggetti

Transcript

1 DAIS Univ. Ca' Foscari Venezia Programmazione ad oggetti Samuel Rota Bulò

2 Ereditarietà E' un meccanismo per estendere le funzionalità di una classe con nuovi campi e nuovi metodi Chiamiamo superclasse: la classe che viene estesa sottoclasse: la classe che estende Esempi: una classe Rettangolo può essere sottoclasse di una classe Poligono. Una classe ContoDeposito può essere sottoclasse di una classe ContoCorrente public class NomeSottoClasse extends NomeSuperClasse{ //nuovi campi //nuovi costruttori //nuovi metodi

3 Ereditarietà vs interfacce Estendere una classe è diverso da implementare un'interfaccia In entrambi i casi otteniamo delle nuove relazioni di sottotipo Interfacce rappresentano le classi che le implementano e altre interfacce che le estendono Le classi rappresentano le sottoclassi che le estendono Differiscono perché Una sottoclasse eredita l'implementazione dei metodi e i campi della superclasse riuso del codice

4 Ereditarietà Estendiamo una classe allo scopo di aggiungere delle funzionalità mancanti o modificare alcune funzionalità della superclasse. Nella definizione di una sottoclasse inseriamo ciò che cambia rispetto alla superclasse. Dalla superclasse ereditiamo tutti i campi ed i metodi ma possiamo accedervi solo se non sono privati. Come possiamo modificare la funzionalità di una superclasse? Ridefinendo l'implementazione di un metodo della superclasse (overriding) Aggiungendo nuovi metodi I nuovi metodi/costruttori aggiunti sono utilizzabili solo su oggetti della sottoclasse.

5 Overriding Effettuiamo l'overriding di un metodo se nella sottoclasse ritroviamo un metodo con: la stessa firma di un metodo della superclasse livello di accesso maggiore o uguale

6 Visibilità Tutti i campi e i metodi di una superclasse sono ereditati automaticamente nella sottoclasse Sono visibili però solo i campi/metodi non privati. La sottoclasse può definire nuovi campi/metodi che non sono presenti nella superclasse e questi saranno accessibili dalla sottoclasse e non dalla superclasse. Un campo di una sottoclasse può avere lo stesso nome di un campo della superclasse Il campo della sottoclasse maschera il campo della superclasse Possiamo riferirci esplicitamente dalla sottoclasse a campi, metodi, costruttori della superclasse usando la keyword super

7 public class BankAccount { private double balance; Esempio public BankAccount(){ public BankAccount(double initial){ balance=initial; public void deposit(double ammount){ balance+=ammount; public void withdraw(double ammount){ balance =ammount; public double getbalance(){ return balance;

8 Esempio public class SavingsAccount extends BankAccount { public SavingsAccount(double interestrate) { this.interestrate=interestrate; public double getinterestrate() { return interestrate; private double interestrate;

9 Esempio BankAccount account=new BankAccount(10); System.out.println(account.getBalance()); //stampa 10 System.out.println(account.getInterestRate()); //ERRORE! SavingsAccount account2=new SavingsAccount(2); System.out.println(account2.getBalance()); //stampa 0 System.out.println(account2.getInterestRate()); //stampa 2 account=account2; account.deposit(100); System.out.println(account.getInterestRate()); //ERRORE! System.out.println(account.getBalance()); //stampa 100 System.out.println(account2.getBalance()); //stampa 100

10 Esempio public class CheckingAccount extends BankAccount{ private static final int FREE_TRANSACTIONS = 3; private static final double TRANSACTION_FEE = 2.0; private int transactioncount; public void deposit(double ammount){ ++transactioncount; balance+=ammount; //ERRORE: balance non visibile deposit(ammount); //ERRORE: loop! super.deposit(ammount); //ok! public void withdraw(double ammount){ ++transactioncount; super.withdraw(ammount); public void deductfees(){ if(transactioncount>free_transactions){ double fee=transaction_fee*(transactioncount FREE_TRANSACTIONS); super.withdraw(fee); transactioncount=0; public int gettransactioncount(){ return transactioncount;

11 Costruttori di sottoclassi Il costruttore di una sottoclasse provvede ad inizializzare i campi delle istanze della sottoclasse Per inizializzare i campi della superclasse all'interno di un costruttore della sottoclasse possiamo invocare il costruttore della superclasse esplicitamente: mettendo super(parametri); come primo comando implicitamente: se non invocato esplicitamente, il compilatore provvede ad inserire la chiamata super() al costruttore di default della superclasse. Se quest'ultimo non esiste abbiamo un errore di compilazione. Sebbene accessibili dalla sottoclasse, i costruttori della superclasse non sono utilizzabili per istanziare un oggetto della sottoclasse.

12 Esempio public class SavingsAccount extends BankAccount { public SavingsAccount(double balance, double interestrate) { super(balance); //invoca il costruttore della superclasse this.interestrate=interestrate; public double getinterestrate() { return interestrate; private double interestrate; SavingsAccount account=new SavingsAccount(10,2); System.out.println(account.getBalance()); //stampa 10 System.out.println(account.getInterestRate()); //stampa 2 SavingsAccount account2=new SavingsAccount(); //ERRORE! SavingsAccount account2=new SavingsAccount(10); //ERRORE!

13 Conversione di tipo Ogni sottoclasse è sottotipo della superclasse. Possiamo assegnare ad una variabile di una classe un riferimento che ha come tipo una sua sottoclasse. Non è possibile assegnare ad una variabile di una classe un riferimento di tipo superclasse, salvo esplicito casting. Con l'operatore instanceof possiamo verificare in anticipo se il casting andrà a buon fine BankAccount baccount=new BankAccount(10); SavingsAccount saccount=new SavingsAccount(10,2); CheckingAccount caccount=new CheckingAccount(); BankAccount account=caccount; //ok saccount=caccount; //ERRORE compile time! caccount=baccount; //ERRORE compile time! caccount=(checkingaccount) baccount; //ERRORE run time! caccount=(checkingaccount) account; //ok account=saccount; //ok System.out.println(((SavingsAccount) account).getinterestrate()); //stampa 2

14 public class BankAccount {... Esempio public void transfer(double ammount, BankAccount recipient){ withdraw(ammount); recipient.deposit(ammount); SavingsAccount account=new SavingsAccount(10,2); BankAccount account2=new BankAccount(100); account2.transfer(10,account); System.out.println(account.getBalance()); //cosa stampa? System.out.println(account2.getBalance()); //cosa stampa?

15 Polimorfismo dynamic dispatch Stesso meccanismo visto per le interfacce Quando invochiamo un metodo di una variabile di una certa classe: il metodo deve esistere nella classe che è tipo statico della variabile e i tipi dei parametri passati devono essere compatibili con quelli del metodo L'implementazione del metodo che verrà invocato è determinato in base al tipo dinamico della variabile CheckingAccount account=new CheckingAccount(100); System.out.println(account.getTransactionCount()); //stampa 0 account.withdraw(10); System.out.println(account.getTransactionCount()); //stampa 1 BankAccount baccount=account; baccount.withdraw(10); System.out.println(account.getTransactionCount()); //cosa stampa? BankAccount account2=new BankAccount(10); account2.transfer(5,account); System.out.println(account.getTransactionCount()); //cosa stampa?

16 Esempio public class A{ public void m(double d){system.out.println( A.m(double) ); public void m(int i){system.out.println( A.m(int) ); public void m(int i, float f){system.out.println( A.m(int,float) ); public void m(float f, int i){system.out.println( A.m(float,int) ); public class B extends A{ public void m(double d){system.out.println( B.m(double) ); public void m(string s){system.out.println( B.m(string) ); public class Test{ public static void main(string args[]){ B b=new B(); A a=new B(); b.m(1); //cosa stampa? b.m(1.2); //cosa stampa? a.m(1); //cosa stampa? a.m(1.2); //cosa stampa? a.m( prova ); //cosa stampa? a=new A(); a.m(1); //cosa stampa? a.m(1.2); //cosa stampa? ((B) a).m(1.1); //cosa stampa? a.m(1,1); //cosa stampa?