Riflessione: Ordinamento di oggetti

Transcript

1 SETTIMANA 7 Riflessione: Ordinamento di oggetti Ordinamento di oggetti Si sono visti algoritmi di ordinamento su array di numeri Ma spesso bisogna ordinare dati più complessi ad esempio stringhe, ma anche oggetti di altro tipo Gli algoritmi di ordinamento che abbiamo esaminato effettuano confronti tra numeri Si possono usare gli stessi algoritmi per ordinare oggetti, a patto che questi siano tra loro confrontabili C è però una differenza confrontare numeri ha un significato matematico ben definito confrontare oggetti ha un significato che dipende dal tipo di oggetto, e a volte può non avere significato alcuno 1 2 Ordinamento di oggetti Confrontare oggetti ha un significato che dipende dal tipo di oggetto quindi la classe che definisce l oggetto deve anche definire il significato del confronto Consideriamo la classe String essa definisce il metodo compareto che attribuisce un significato ben preciso all ordinamento tra stringhe l ordinamento lessicografico Possiamo quindi riscrivere, ad esempio, il metodo selectionsort per ordinare stringhe invece di ordinare numeri, senza cambiare l algoritmo 3 SelectionSort per stringhe public class ArrayAlgs public static void selectionsort(string[] v, int vsize) for (int i = 0; i < vsize - 1; i++) int minpos = findminpos(v, i, vsize-1); if (minpos!= i) swap(v, minpos, i); //abbiamo usato due metodi ausiliari, swap e findminpos private static void swap(string[] v, int i, int j) String temp = v[i]; v[i] = v[j]; v[j] = temp; private static int findminpos(string[] v, int from, int to) int pos = from; String min = v[from]; for (int i = from + 1; i <= to; i++) if (v[i].compareto(min) < 0) pos = i; min = v[i]; return pos; 4

2 Ordinamento di oggetti Si possono riscrivere tutti i metodi di ordinamento e ricerca visti per i numeri interi ed usarli per le stringhe Ma come fare per altre classi? Possiamo ordinare oggetti di tipo BankAccount in ordine, ad esempio, di saldo crescente? Bisogna definire nella classe BankAccount un metodo analogo al metodo compareto della classe String Bisogna riscrivere i metodi perché accettino come parametro un array di BankAccount Non possiamo certo usare questo approccio per qualsiasi classe, deve esserci un sistema migliore! In effetti c'è, ma dobbiamo prima studiare l'ereditarietà e l'uso di interfacce in Java poi torneremo sul problema di ordinare oggetti generici 5 6 L ereditarietà Ereditarietà (capitolo 10) L ereditarietà è uno dei principi basilari della programmazione orientata agli oggetti L ereditarietà è un paradigma che supporta l obiettivo di riusabilità del codice si usa quando si deve realizzare una classe ed è già disponibile un altra classe che rappresenta un concetto più generale 7 8

3 L ereditarietà Supponiamo di voler realizzare una classe SavingsAccount per rappresentare un conto bancario di risparmio, Dovrà avere un tasso di interesse annuo determinato al momento dell apertura Dovrà avere un metodo addinterest per accreditare gli interessi sul conto Un conto bancario di risparmio ha tutte le stesse caratteristiche di un conto bancario, più alcune altre caratteristiche che gli sono peculiari Allora possiamo riutilizzare il codice già scritto per la classe BankAccount 9 La classe BankAccount public class BankAccount public BankAccount() balance = 0; public void deposit(double amount) balance = balance + amount; public void withdraw(double amount) balance = balance - amount; public double getbalance() return balance; private double balance; 10 La classe SavingsAccount public class SavingsAccount public SavingsAccount(double rate) balance = 0; interestrate = rate; public void addinterest() deposit(getbalance() * interestrate / 100); private double interestrate; public void deposit(double amount) balance = balance + amount; public void withdraw(double amount) balance = balance - amount; public double getbalance() return balance; Riutilizzo del codice Come avevamo previsto, buona parte del codice scritto per BankAccount ha potuto essere copiato nella definizione della classe SavingsAccount Abbiamo poi fatto tre cambiamenti abbiamo aggiunto una variabile di esemplare interestrate abbiamo modificato il costruttore ovviamente il costruttore ha anche cambiato nome abbiamo aggiunto un metodo addinterest private double balance; 11 12

4 Riutilizzo del codice Copiare il codice è già un risparmio di tempo, però non è sufficiente Cosa succede se modifichiamo BankAccount? ad esempio, modifichiamo withdraw in modo da impedire che il saldo diventi negativo Dobbiamo modificare di conseguenza anche SavingsAccount molto scomodo fonte di errori L ereditarietà risolve questi problemi 13 SavingsAccount Ri scriviamo la classe SavingsAccount usando il meccanismo dell'ereditarietà Dichiariamo che SavingsAccount è una classe derivata da BankAccount (extends) eredita tutte le caratteristiche di BankAccount specifichiamo soltanto le peculiarità di SavingsAccount public class SavingsAccount extends BankAccount public SavingsAccount(double rate) interestrate = rate; public void addinterest() deposit(getbalance() * interestrate / 100); private double interestrate; 14 Come usare la classe derivata Osservazioni su SavingsAccount Oggetti della classe derivata SavingsAccount si usano come se fossero oggetti di BankAccount con qualche proprietà in più SavingsAccount acct = new SavingsAccount(10); acct.deposit(500); acct.withdraw(200); acct.addinterest(); System.out.println(acct.getBalance()); 330 La classe derivata si chiama sottoclasse La classe da cui si deriva si chiama superclasse Il metodo addinterest usa i metodi getbalance e deposit di BankAccount Non specifica un parametro implicito Cioè il parametro implicito è this Il metodo addinterest invoca getbalance e deposit invece che leggere/scrivere direttamente il campo balance Questo perché il campo balance è definito come private in BankAccount Mentre addinterest è definito in SavingsAccount e non ha accesso a balance 15 16

5 La superclasse universale Object In Java, ogni classe che non deriva da nessun altra deriva implicitamente dalla superclasse universale del linguaggio, che si chiama Object Quindi, SavingsAccount deriva da BankAccount, che a sua volta deriva da Object Object ha alcuni metodi, che vedremo più avanti (tra cui tostring), che quindi sono ereditati da tutte le classi in Java l ereditarietà avviene anche su più livelli, quindi SavingsAccount eredita anche le proprietà di Object Ereditarietà Sintassi: class NomeSottoclasse extends NomeSuperclasse costruttori nuovi metodi nuove variabili Scopo: definire la classe NomeSottoclasse che deriva dalla classe NomeSuperclasse definendo nuovi metodi e/o nuove variabili, oltre ai suoi costruttori Nota: una classe estende sempre una sola altra classe Nota: se la superclasse non è indicata esplicitamente, il compilatore usa implicitamente java.lang.object Confondere superclassi e sottoclassi Terminologia e notazione Dato che oggetti di tipo SavingsAccount sono un estensione di oggetti di tipo BankAccount più grandi di oggetti di tipo BankAccount, nel senso che hanno una variabile di esemplare in più più abili di oggetti di tipo BankAccount, perché hanno un metodo in più perché mai SavingsAccount si chiama sottoclasse e non superclasse? è facile fare confusione verrebbe forse spontaneo usare i nomi al contrario 19 20

6 Confondere superclassi e sottoclassi I termini superclasse e sottoclasse derivano dalla teoria degli insiemi I conti bancari di risparmio (gli oggetti di tipo SavingsAccount) costituiscono un sottoinsieme dell insieme di tutti i conti bancari (gli oggetti di tipo BankAccount) BankAccount SavingsAccount Diagrammi e gerarchie di ereditarietà Abbiamo già visto diagrammi di classi per visualizzare accoppiamento tra classi In un diagramma di classi l ereditarietà viene rappresentata mediante una freccia con la punta a triangolo vuoto, diretta verso la superclasse. Abbiamo già visto diagrammi di ereditarietà La gerarchia delle classi di eccezioni Le gerarchie delle classi del pacchetto io InputStream, OutputStream, Reader, Writer Gerarchia delle eccezioni È tutto chiaro? 1.Quali sono i campi di esemplare presenti in un oggetto di tipo SavingsAccount? 2.Elencare quattro metodi che possono essere invocati con un oggetto di tipo SavingsAccount 3.Se la classe Manager estende Employee, qual è la superclasse e quale la sottoclasse? 23 24

7 Metodi di una sottoclasse Metodi di una sottoclasse Quando definiamo una sottoclasse, possono verificarsi tre diverse situazioni per quanto riguarda i suoi metodi nella sottoclasse viene definito un metodo che nella superclasse non esisteva Ad esempio il metodo addinterest di SavingsAccount un metodo della superclasse viene ereditato dalla sottoclasse Ad esempio i metodi deposit, withdraw, getbalance di SavingsAccount, ereditati da BankAccount un metodo della superclasse viene sovrascritto nella sottoclasse Vediamo ora un esempio anche di questo caso Sovrascrivere un metodo La possibilità di sovrascrivere (override) un metodo della superclasse, modificandone il comportamento quando è usato per la sottoclasse, è una delle caratteristiche più potenti di OOP Per sovrascrivere un metodo bisogna definire nella sottoclasse un metodo con la stessa firma di quello definito nella superclasse tale metodo prevale su quello della superclasse quando viene invocato con un oggetto della sottoclasse Sovrascrivere un metodo: esempio Vogliamo modificare la classe SavingsAccount in modo che ogni operazione di versamento abbia un costo (fisso) FEE, che viene automaticamente addebitato sul conto I versamenti nei conti di tipo SavingsAccount si fanno però invocando il metodo deposit di BankAccount, sul quale non abbiamo controllo Possiamo però sovrascrivere deposit, ridefinendolo in SavingsAccount In più aggiungiamo una costante di classe FEE, che contenga l'importo del costo fisso da addebitare 27 28

8 Sovrascrivere un metodo: esempio Sovrascriviamo il metodo deposit public class SavingsAccount extends BankAccount public void deposit(double amount) withdraw(fee); // aggiungi amount a balance private final static double FEE = 2.58; // euro Quando viene invocato deposit con un oggetto di tipo SavingsAccount, viene invocato il metodo deposit definito in SavingsAccount e non quello definito in BankAccount nulla cambia per oggetti di tipo BankAccount, ovviamente 29 Sovrascrivere un metodo: esempio Proviamo a completare il metodo dobbiamo versare amount e sommarlo a balance non possiamo modificare direttamente balance, che è una variabile privata in BankAccount l unico modo per aggiungere una somma di denaro a balance è l invocazione del metodo deposit public class SavingsAccount extends BankAccount public void deposit(double amount) withdraw(fee); deposit(amount); // NON FUNZIONA Così non funziona, perché il metodo diventa ricorsivo con ricorsione infinita!!! (manca il caso base ) 30 Sovrascrivere un metodo: Esempio Ciò che dobbiamo fare è invocare il metodo deposit di BankAccount Questo si può fare usando il riferimento implicito super, gestito automaticamente dal compilatore per accedere agli elementi ereditati dalla superclasse public class SavingsAccount extends BankAccount public void deposit(double amount) withdraw(fee); super.deposit(amount); //invoca deposit della superclasse 31 Invocare un metodo della superclasse Sintassi: super.nomemetodo(parametri) Scopo: invocare il metodo nomemetodo della superclasse anziché il metodo con lo stesso nome (sovrascritto) della classe corrente super è un riferimento all'oggetto parametro implicito del metodo, come il riferimento this super viene creato al momento dell'invocazione del metodo, come il riferimento this Però super tratta l'oggetto a cui si riferisce come se fosse un esemplare della superclasse: questa è l'unica differenza tra super e this 32

9 Ereditare campi di esemplare Campi di esemplare di una sottoclasse Quando definiamo una sottoclasse, possono verificarsi solo due diverse situazioni per quanto riguarda i suoi campi di esemplare nella sottoclasse viene definito un campo di esemplare che nella superclasse non esisteva Ad esempio il campo interestrate di SavingsAccount un campo della superclasse viene ereditato dalla sottoclasse Ad esempio il campo balance di SavingsAccount, ereditato da BankAccount Non è possibile sovrascrivere un campo della superclasse nella sottoclasse Ereditare campi di esemplare Cosa succede se nella sottoclasse viene definito un campo omonimo di uno della superclasse? È un operazione lecita Ma è sconsigliabile Un oggetto della sottoclasse avrà due campi di esemplare con lo stesso nome ma in generale valori diversi In particolare il nuovo campo di esemplare mette in ombra il suo omonimo della superclasse Ereditare campi di esemplare public class SavingsAccount extends BankAccount public void deposit(double amount) withdraw(fee); balance = balance + amount; private double balance; // Meglio non farlo! In questo caso la compilazione ha successo Ma viene aggiornata la variabile balance sbagliata! Gli altri metodi, ereditati da BankAccount, faranno riferimento alla variabile balance ereditata da BankAccount 35 36

10 Mettere in ombra campi ereditati Perchè Java presenta questa apparente debolezza? Chi scrive una sottoclasse non deve conoscere niente di quanto dichiarato private nella superclasse, né scrivere codice che si basa su tali caratteristiche: incapsulamento! quindi è perfettamente lecito definire e usare una variabile balance nella sottoclasse sarebbe strano impedirlo: chi progetta la sottoclasse non sa che esiste una variabile balance nella superclasse! Ma non si può usare nella sottoclasse variabili omonime di quelle della superclasse e sperare che siano la stessa cosa Costruttori di una sottoclasse Costruttori di una sottoclasse public class SavingsAccount extends BankAccount public SavingsAccount(double rate) interestrate = rate; Che ne è delle altre variabili di esemplare? In questo caso balance Possiamo utilizzare i costruttori della superclasse per inizializzarle? 39 Costruttori di una sottoclasse Come per i metodi, possiamo usare il riferimento super per riferirci ai costruttori della superclasse La parola chiave super seguita da parentesi tonde indica una chiamata al costruttore della superclasse Tale chiamata deve essere il primo enunciato del costruttore della sottoclasse public class SavingsAccount extends BankAccount public SavingsAccount( double initialbalance, double rate) super(initialbalance); interestrate = rate; 40

11 Costruttori di una sottoclasse E se non invochiamo un costruttore della superclasse? Allora viene invocato il costruttore predefinito della superclasse (quello privo di parametri espliciti) Se questo non esiste (tutti i costruttori della superclasse richiedono parametri espliciti) viene generato un errore in compilazione public class SavingsAccount extends BankAccount public SavingsAccount(double rate) //super(); invocato automaticamente interestrate = rate; È tutto chiaro? 1.Perché il costruttore di SavingsAccount visto prima non invoca il costruttore della superclasse? 2.Quando si invoca un metodo della superclasse usando l enunciato super, l invocazione deve essere il primo enunciato del metodo della sottoclasse? La classe CheckingAccount Esercizio: la classe CheckingAccount public class CheckingAccount extends BankAccount public CheckingAccount(double initialbalance) super(initialbalance); // costruisci la superclasse transactioncount = 0; // azzera conteggio transaz. public void deposit(double amount) //SOVRASCRITTO!! transactioncount++; super.deposit(amount); // aggiungi amount al saldo 43 public void withdraw(double amount) //SOVRASCRITTO!! transactioncount++; super.withdraw(amount); // sottrai amount dal saldo // continua 44

12 La classe CheckingAccount La superclasse BankAccount // continua public void deductfees() //NUOVO METODO if (transactioncount > FREE_TRANSACTIONS) double fees = TRANSACTION_FEE * (transactioncount FREE_TRANSACTIONS); super.withdraw(fees); transactioncount = 0; //nuovi campi di esemplare private int transactioncount; private static final int FREE_TRANSACTIONS = 3; private static final double TRANSACTION_FEE = 2.0; 45 public class BankAccount public BankAccount() balance = 0; public BankAccount(double initialbalance) balance = initialbalance; public void deposit(double amount) balance = balance + amount; public void withdraw(double amount) balance = balance - amount; public double getbalance() return balance; public void transfer(double amount, BankAccount other) withdraw(amount); other.deposit(amount); private double balance; 46 È tutto chiaro? 1.Perché il metodo withdraw di CheckingAccount invoca super.withdraw? 2.Perché il metodo deductfees pone a zero il conteggio delle transazioni effettuate? Conversioni di tipo tra superclasse e sottoclasse 47 48

13 Conversione fra riferimenti Un oggetto di tipo SavingsAccount è un caso speciale di oggetti di tipo BankAccount Questa proprietà si riflette in una proprietà sintattica una variabile oggetto del tipo di una superclasse può riferirsi ad un oggetto di una classe derivata non c è nessuna conversione effettiva, cioè non vengono modificati i dati Conversione fra riferimenti Le tre variabili, di tipi diversi, puntano ora allo stesso oggetto SavingsAccount collegefund = new SavingsAccount(10); //tutto ok BankAccount anaccount = collegefund; // questo è lecito!! Object anobject = collegefund; // anche questo!! SavingsAccount collegefund = new SavingsAccount(10); //tutto ok BankAccount anaccount = collegefund; // questo è lecito!! Object anobject = collegefund; // anche questo!! Conversione fra riferimenti SavingsAccount collegefund = new SavingsAccount(10); BankAccount anaccount = collegefund; anaccount.deposit(10000); // questo è lecito perché // deposit è un metodo di BankAccount Tramite la variabile anaccount si può usare l oggetto come se fosse di tipo BankAccount, Però non si può accedere alle proprietà specifiche di SavingsAccount anaccount.addinterest(); // questo NON è lecito perché //addinterest NON è metodo di BankAccount cannot resolve symbol symbol : method addinterest() location: class BankAccount anaccount.addinterest(); ^ Conversione tra riferimenti Aggiungiamo il metodo transferto a BankAccount public class BankAccount public void transferto(bankaccount other, double amount) withdraw(amount); // ovvero, this.withdraw() other.deposit(amount); BankAccount acct1 = new BankAccount(500); BankAccount acct2 = new BankAccount(); acct1.transferto(acct2, 200); System.out.println(acct1.getBalance()); System.out.println(acct2.getBalance()); Per quanto detto finora, il parametro other può anche riferirsi ad un oggetto di tipo SavingsAccount BankAccount other = new BankAccount(1000); SavingsAccount sacct = new SavingsAccount(10); BankAccount bacct = sacct; other.transferto(bacct, 500); 1 error

14 Conversione fra riferimenti La conversione tra riferimento a sottoclasse e riferimento a superclasse può avvenire anche implicitamente (come tra int e double) BankAccount other = new BankAccount(1000); SavingsAccount sacct = new SavingsAccount(10); other.transferto(sacct, 500); Il compilatore sa che il metodo transferto richiede un riferimento di tipo BankAccount, quindi controlla che sacct sia un riferimento di tipo BankAccount o di una sua sottoclasse effettua la conversione automaticamente 53 Conversione fra riferimenti Vediamo la conversione inversa di quella vista finora Ovvero la conversione di un riferimento a superclasse in un riferimento a sottoclasse Questa non può avvenire automaticamente BankAccount bacct = new BankAccount(1000); SavingsAccount sacct = bacct; incompatible types found : BankAccount required: SavingsAccount sacct = bacct; ^ 1 error Ma ha senso cercare di effettuarla? In generale non ha senso, perché in generale un oggetto della superclasse non è un oggetto della sottoclasse 54 Conversione fra riferimenti Tale conversione ha senso soltanto se, per le specifiche dell algoritmo, siamo sicuri che il riferimento a superclasse punta in realtà ad un oggetto della sottoclasse Richiede un cast esplicito Richiede attenzione, perché se ci siamo sbagliati verrà lanciata un eccezione Polimorfismo ed ereditarietà SavingsAccount sacct = new SavingsAccount(1000); BankAccount bacct = sacct; SavingsAccount sacct2 = (SavingsAccount) bacct; // se in fase di esecuzione bacct non punta // effettivamente ad un oggetto SavingsAccount // l interprete lancia ClassCastException 55 56

15 Polimorfismo Sappiamo che un oggetto di una sottoclasse può essere usato come se fosse un oggetto della superclasse BankAccount acct = new SavingsAccount(10); acct.deposit(500); acct.withdraw(200); Ma quale metodo deposit viene invocato, quello di BankAccount o quello ridefinito in SavingsAccount? acct è una variabile dichiarata di tipo BankAccount Ma contiene un riferimento ad un oggetto che, in realtà, è di tipo SavingsAccount! Questa informazione è disponibile solo in esecuzione (all'interprete Java), non in compilazione secondo la semantica di Java, viene invocato il metodo deposit di SavingsAccount 57 Polimorfismo In Java il tipo di una variabile non determina in modo completo il tipo dell oggetto a cui essa si riferisce Questa semantica si chiama polimorfismo ( molte forme ) ed è caratteristica dei linguaggi Object Oriented La stessa operazione (ad es. deposit) può essere svolta in modi diversi, a seconda dell'oggetto a cui ci si riferisce L invocazione di un metodo è sempre determinata dal tipo dell oggetto effettivamente usato come parametro implicito, e NON dal tipo della variabile oggetto La variabile oggetto ci dice cosa si può fare con quell'oggetto (cioè quali metodi si possono utilizzare) L'oggetto ci dice come farlo 58 Polimorfismo Abbiamo già visto il polimorfismo a proposito dei metodi sovraccarichi l invocazione del metodo println si traduce in una invocazione di un metodo scelto fra alcuni metodi con firme diverse il compilatore decide quale metodo invocare In questo caso la situazione è molto diversa, perché la decisione non può essere presa dal compilatore, ma deve essere presa dall ambiente runtime (l interprete) Si parla di selezione posticipata (late binding) Mentre nel caso di metodi sovraccarichi si parla di Controllo del tipo e instanceof Se si vuole controllare il tipo dell'oggetto a cui una variabile oggetto si riferisce, si può usare un nuovo operatore: instanceof È un operatore relazionale (restituisce valori booleani) Restituisce true se la variabile oggetto (primo argormento sta puntando ad un oggetto del tipo specificato dal secondo argomento Ad esempio SavingsAccount collegefund = new SavingsAccount(10); BankAccount anaccount = collegefund; if (anaccount instanceof SavingsAccount) SavingsAccount a = (SavingsAccount) anaccount; Restituisce true selezione anticipata (early binding) 59 Possiamo effettuare il cast in tranquillità 60

16 Controllo del tipo e instanceof Sintassi: varoggetto instanceof NomeClasse Restituisce true se varoggetto contiene un riferimento ad un oggetto della classe NomeClasse (o una sua sottoclasse) false altrimenti In caso di valore restituito true un eventuale cast di varoggetto ad una variabile di tipo NomeClasse NON lancia l eccezione ClassCastException Nota: il risultato non dipende dal tipo di varoggetto, ma dal tipo dell oggetto a cui essa si riferisce al momento dell esecuzione Esercizio: polimorfismo La classe AccountTester (vers. 1) public class AccountTester1 public static void main(string[] args) SavingsAccount momssavings = new SavingsAccount(0.5); CheckingAccount harryschecking = new CheckingAccount(100); // metodi polimorfici di BankAccount e sue sottoclassi momssavings.deposit(10000); momssavings.transfer(2000, harryschecking); harryschecking.withdraw(1500); harryschecking.withdraw(80); momssavings.transfer(1000, harryschecking); harryschecking.withdraw(400); La classe AccountTester (vers. 2) public class AccountTester2 public static void main(string[] args) BankAccount momssavings = new SavingsAccount(0.5); BankAccount harryschecking = new CheckingAccount(100); // metodi polimorfici di BankAccount e sue sottoclassi momssavings.deposit(10000);//vengono invocati i metodi delle momssavings.transfer(2000, harryschecking); //sottoclassi harryschecking.withdraw(1500); //anche se i riferimenti sono harryschecking.withdraw(80); //di tipo BankAccount momssavings.transfer(1000, harryschecking); harryschecking.withdraw(400); // simulazione della fine del mese momssavings.addinterest(); //metodo solo di SavingsAccount harryschecking.deductfees();//metodo solo di CheckingAccount System.out.println("Mom s savings balance = $" + momssavings.getbalance()); System.out.println("Harry s checking balance = $" + harryschecking.getbalance()); 63 // simulazione della fine del mese ((SavingsAccount)momsSavings).addInterest(); //e` necessario ((CheckingAccount)harrysChecking).deductFees();//fare i cast System.out.println("Mom s savings balance = $" + momssavings.getbalance()); System.out.println("Harry s checking balance = $" + harryschecking.getbalance()); 64

17 Riflessione: Object Oriented Programming Obiettivi e principi di design OOP obiettivi Robustezza Vogliamo scrivere programmi capaci di gestire situazioni inaspettate (ad es. input inattesi) Requisito particolarmente importante in applicazioni lifecritical Adattabilità Vogliamo scrivere programmi capaci di evolvere (ad es. girare su diverse architetture o avere nuove funzionalità) Un concetto correlato è quello di portabilità Riusabilità Vogliamo che il nostro codice sia utilizzabile come componente di diversi sistemi in varie applicazioni Deve essere chiaro cosa il nostro codice fa, e cosa non fa OOP principi di design Astrazione Distillare i concetti che meglio rappresentano un oggetto o un sistema Information hiding Nascondere l informazione ad utenti esterni, lasciando vedere solo l interfaccia In questo modo parti di un programma possono cambiare senza effetti sulle altre Modularità Organizzare un sistema software in componenti funzionali separate Tutti questi principi di design Sono supportati in un linguaggio di programmazione OO Aiutano ad ottenere robustezza, adattabilità, riusabilità 67 OOP Paradigmi Abbiamo esaminato i tre principali paradigmi di programmazione che caratterizzano un linguaggio OO Classi, oggetti, incapsulamento L informazione viene nascosta dentro scatole nere (le classi), e l accesso ad essa è controllato Ereditarietà Una classe può essere estesa da sottoclassi, che ne ereditano le funzioni e le specializzano Polimorfismo Il tipo di una variabile non determina completamente il tipo dell oggetto a cui essa si riferisce 68

18 La superclasse universale Object La classe Object Sappiamo già che ogni classe di Java è (in maniera diretta o indiretta) sottoclasse di Object Quindi ogni classe di Java eredita tutti i metodi della classe Object Alcuni dei più utili metodi di Object sono i seguenti Ma perché siano davvero utili, nella maggior parte dei casi bisogna sovrascriverli Sovrascrivere il metodo tostring 71 Metodi magici Il metodo println, è in grado di ricevere come parametro un oggetto di qualsiasi tipo Ora siamo in grado di comprendere questa magia qualsiasi riferimento può sempre essere convertito automaticamente in un riferimento di tipo Object public void println(object obj) //invocato per oggetti generici println(obj.tostring()); public void println(string s) // invocato per le stringhe Ma un esemplare di String è anche di tipo Object come viene scelto, tra i metodi sovraccarichi, quello giusto quando si invoca println con una stringa? Il compilatore cerca sempre di fare il minor numero di conversioni viene usato, quindi, il metodo più specifico 72

19 Il metodo tostring Passando un oggetto qualsiasi a System.out.println si visualizza la sua descrizione testuale standard println invoca tostring dell oggetto, e l invocazione è possibile perché tutte le classi hanno il metodo tostring, eventualmente ereditato da Object BankAccount a = new BankAccount(1000); System.out.println(a); Il metodo tostring di una classe viene invocato implicitamente anche per concatenare un oggetto con una stringa: BankAccount acct = new BankAccount(); String s = "Conto " + acct; La seconda riga viene interpretata dal compilatore come se fosse stata scritta così: String s = "Conto " + acct.tostring(); 73 Il metodo tostring Il metodo tostring della classe Object ha la firma public String tostring() L invocazione di questo metodo per qualsiasi oggetto ne restituisce la descrizione testuale standard il nome della classe seguito dal e dallo hashcode dell oggetto Che è un numero univocamente determinato dall indirizzo in memoria dell oggetto stesso BankAccount a = new BankAccount(1000); System.out.println(a); BankAccount@111f71 In generale la descrizione testuale standard non è particolarmente utile È piu utile ottenere una stringa di testo contenente informazioni sullo stato dell oggetto in esame 74 Sovrascrivere il metodo tostring Sovrascrivere il metodo tostring nelle classi che si scrivono è considerato buono stile di programmazione tostring dovrebbe sempre produrre una stringa contenente tutte le informazioni di stato dell oggetto Il valore di tutte le sue variabili di esemplare Il valore di variabili statiche non costanti della classe Questo stile di programmazione è molto utile per il debugging ed è usato nella libreria standard Esempio: descrizione testuale di BankAccount Esempio: tostring in BankAccount tostring crea una stringa contenente il nome della classe seguito dai valori dei campi di esemplare racchiusi fra parentesi quadre. public class BankAccount public String tostring() return "BankAccount[balance=" + balance + "]"; System.out.println(anAccount); BankAccount[balance=1500] Bisogna sovrascrivere tostring in BankAccount 75 76

20 Materiale di complemento (capitolo 10) Metodo tostring: lo stile adottato nella libreria standard Esempio: tostring in BankAccount Stile adottato nella libreria standard: tostring crea una stringa contenente il nome della classe seguito dai valori dei campi di esemplare racchiusi fra parentesi quadre. public class BankAccount public String tostring() return BankAccount[balance= + balance + ] ; Problema: devo sovrascrivere tostring anche per le sottoclassi, per vedere stampato il nome di classe corretto 79 Esempio: tostring in BankAccount È possibile evitare di scrivere esplicitamente il nome della classe all interno del metodo Si può usare il metodo getclass, che restituisce un oggetto di tipo classe E poi invocare il metodo getname sull oggetto di tipo classe, per ottenere il nome della classe public String tostring() return getclass().getname() + [balance= + balance + ] ; tostring visualizza il nome corretto della classe anche quando viene invocato su un oggetto di una sottoclasse 80

21 Esempio: tostring in SavingsAccount Ovviamente, se si vogliono visualizzare i valori di nuovi campi di esemplare di una sottoclasse bisogna sovrascrivere tostring Bisogna invocare super.tostring per ottenere i valori dei campi della superclasse Controllo di accesso public class SavingsAccount extends BankAccount public String tostring() return super.tostring() + [interestrate= + interestrate + ] ; Controllo di accesso Java fornisce quattro livelli per il controllo di accesso a metodi, campi, e classi public private protected package Finora noi abbiamo sempre usato solo i primi due Ora siamo in grado di comprendere anche gli altri due In particolare lo specificatore di accesso protected Accesso package Un membro di classe (o una classe) per il quale non viene specificato un identificatore di accesso ha un impostazione di accesso predefinita Accesso di pacchetto Tutti i metodi delle classi contenute nello stesso pacchetto vi hanno accesso Può essere una buona impostazione per le classi Non lo è per le variabili, perché si viola l incapsulamento dell informazione 83 84

22 Accesso package Errore comune: dimenticare lo specificatore di accesso per una variabile di esemplare public class Window extends Container String warningstring; Questo è un rischio per la sicurezza Un altro programmatore può realizzare una nuova classe nello stesso pacchetto e ottenere l accesso al campo di esemplare È meglio usare (quasi) sempre campi di esemplare private 85 Accesso protected Abbiamo visto che una sottoclasse non può accedere a campi private ereditati dalla propria superclasse Deve usare i metodi (public) appropriati della superclasse Esempio: il metodo addinterest di SavingsAccount public class SavingsAccount extends BankAccount public void addinterest() deposit(getbalance() * interestrate / 100); 86 Accesso protected public class BankAccount protected double balance; Il progettista della superclasse può rendere accessibile in modo protected un campo di esemplare Tutte le sottoclassi vi hanno accesso Attenzione: è una violazione dell incapsulamento Il progettista della superclasse non ha alcun controllo sui progettisti di eventuali sottoclassi Diventa difficile modificare la superclasse: non si possono modificare variabili protected perché qualcuno potrebbe aver scritto una sottoclasse che ne fa uso Anche i metodi possono essere definiti protected possono essere invocati solo nella classe in cui sono definiti e nelle classi da essa derivate 87 Il modificatore di accesso final 88

23 Classi e metodi final Abbiamo già visto che la parola chiave final può essere usata nella definizione di una variabile per impedire successive assegnazioni di valori Anche un metodo di una classe può essere dichiarato come final Un metodo di una classe dichiarato final non può essere sovrascritto dalle sottoclassi Anche una intera classe può essere dichiarata come final Una classe dichiarata final non può essere estesa Classi e metodi final Esempio: la classe String è una classe immutabile Gli oggetti di tipo String non possono essere modificati da nessuno dei loro metodi La classe String nella libreria standard è dichiarata in questo modo: public final class String Nessuno può creare sottoclassi di String Quindi siamo sicuri che riferimenti ad oggetti di tipo String si possono sempre copiare senza rischi di cambiamenti Classi e metodi final In alcune circostanze può essere utile dichiarare un metodo come final Esempio: un metodo per verificare la correttezza di una chiave public class SecureAccount extends BankAccount public final boolean checkpassword(string password) È tutto chiaro? 1.Quale è una comune motivazione che porta a definire campi di esemplare con accesso di pacchetto? 2.Se una classe dotata di costruttore pubblico ha accesso di pacchetto, chi ne può costruire esemplari? In questo modo nessuno può sovrascriverlo con un metodo che restituisca sempre true 91 92

24 Interfacce (capitolo 9) e l interfaccia Comparable (sezione 13.8) Realizzare una proprietà astratta Torniamo al problema enunciato qualche giorno fa: ordinare oggetti generici Affinché i suoi esemplari possano essere ordinati, una classe deve definire un metodo adatto a confrontare esemplari della classe, con lo stesso comportamento di compareto Gli oggetti della classe diventano confrontabili gli algoritmi di ordinamento/ricerca non hanno bisogno di conoscere alcun particolare del criterio di confronto tra gli oggetti basta che gli oggetti siano tra loro confrontabili 95 Scrivere una interfaccia Sintassi: public interface NomeInterfaccia firme di metodi La definizione di una interfaccia in Java serve per definire un comportamento astratto Una interfaccia deve poi essere realizzata (implementata) da una classe che dichiari di avere tale comportamento Definire un interfaccia è simile a definire una classe si usa la parola chiave interface al posto di class Un interfaccia può essere vista come una classe ridotta non può avere costruttori non può avere variabili di esemplare contiene le firme di uno o più metodi non statici (definiti implicitamente public), ma non può definirne il codice 96

25 Implementare una interfaccia Esempio: L'interfaccia Comparable public interface Comparable int compareto(object other); Se una classe intende realizzare concretamente un comportamento astratto definito in un interfaccia, deve Dichiarare di implementare l interfaccia Definire i metodi dell interfaccia, con la stessa firma public class BankAccount implements Comparable public int compareto(object other) //other è un Object perché questa è la firma in //Comparable. Però facciamo un cast a BankAccount BankAccount acct = (BankAccount) other; if (balance < acct.balance) return -1; if (balance > acct.balance) return 1; return 0; 97 Conversione di tipo tra classi e interfacce 98 Usare una interfaccia In generale, valgono le regole di conversione viste nell'ambito dell'ereditarietà Una interfaccia ha lo stesso ruolo di una superclasse Una classe che implementa un'interfaccia ha lo stesso ruolo di una sottoclasse che estende la superclasse È lecito definire una variabile il cui tipo è un'interfaccia Comparable c; // corretto Ma non è possibile costruire oggetti da un interfaccia new Comparable(); // ERRORE IN COMPILAZIONE Le interfacce non hanno campi di esemplare nè costruttori Allora a che serve avere una variabile oggetto il cui tipo è quello di una interfaccia? 99 Conversione da classe ad interfaccia Una variabile oggetto di tipo Comparable può puntare ad un oggetto di una classe che realizza Comparable Comparable c = new BankAccount(10); //corretto Usando la variabile c non sappiamo esattamente quale è il tipo dell'oggetto a cui essa si riferisce Non possiamo utilizzare tutti i metodi di BankAccount double saldo = c.getbalance(); //ERRORE in compilazione Però siamo sicuri che quell'oggetto ha un metodo compareto Comparable d = new BankAccount(20); if ( c.compareto(d) > 0 ) //corretto 100

26 Conversione da interfaccia a classe A volte può essere necessario convertire un riferimento il cui tipo è un interfaccia in un riferimento il cui tipo è una classe che implementa l'interfaccia Comparable c = new BankAccount(10); double saldo = c.getbalance(); //ERRORE! Come faccio? Se siamo certi che c punta ad un oggetto di tipo BankAccount possiamo creare una nuova variabile acct di tipo BankAccount e fare un cast di c su acct Comparable c = new BankAccount(10); BankAccount acct = (BankAccount) c; double saldo = anaccount.getbalance(); //corretto Polimorfismo e interfacce E se ci sbagliamo? ClassCastException in esecuzione Polimorfismo e interfacce Comparable x; if () x = new BankAccount(1000); else x = new String( ); if (x.compareto(y) > 0) Possiamo invocare il metodo compareto perché x è di tipo Comparable Ma quale metodo compareto? Quello scritto in BankAccount o quello di String? Il compilatore non ha questa informazione Il tipo di oggetto a cui x si riferisce dipende dal flusso di esecuzione In fase di esecuzione la JVM determina il tipo di oggetto a cui x si riferisce e applica il metodo corrispondente 103 Polimorfismo e interfacce Il tipo di una variabile non determina in modo completo il tipo dell oggetto a cui essa si riferisce Come per l'ereditarietà, questa semantica si chiama polimorfismo La stessa operazione (compareto) può essere svolta in modi diversi, a seconda dell'oggetto a cui ci si riferisce L invocazione di un metodo è sempre determinata dal tipo dell oggetto effettivamente usato come parametro implicito, e NON dal tipo della variabile oggetto La variabile oggetto (interfaccia) ci dice cosa si può fare con quell'oggetto (cioè quali metodi si possono utilizzare) L'oggetto (appartenente ad una classe) ci dice come farlo 104

27 Polimorfismo e interfacce Comparable x; if () x = new BankAccount(1000); else x = new String( ); if (x.compareto(y) > 0) Se la condizione dell'if è vera, x contiene un riferimento ad un oggetto che, in quel momento dell'esecuzione è di tipo BankAccount! E l interprete Java lo sa (il compilatore no) secondo la semantica di Java, viene invocato il metodo compareto scritto in BankAccount Ordinamento di oggetti e l'interfaccia Comparable L interfaccia Comparable public interface Comparable int compareto(object other); L interfaccia Comparable è definita nel pacchetto java.lang, per cui non deve essere importata né deve essere definita la classe String, ad esempio, implementa Comparable Come può Comparable risolvere il nostro problema? Ovvero definire un metodo di ordinamento valido per tutte le classi? Basta definire un metodo per ordinare un array di riferimenti ad oggetti che realizzano Comparable, indipendentemente dal tipo Ordinamento di oggetti Tutti i metodi di ordinamento e ricerca che abbiamo visto per array di numeri interi possono essere riscritti per array di oggetti Comparable Basta usare le seguenti traduzioni if (a < b) if (a > b) if (a == b) if (a!= b) if (a.compareto(b) < 0) if (a.compareto(b) > 0) if (a.compareto(b) == 0) if (a.compareto(b)!= 0)

28 SelectionSort per oggetti Comparable public class ArrayAlgs public static void selectionsort(comparable[] v, int vsize) for (int i = 0; i < vsize - 1; i++) int minpos = findminpos(v, i, vsize-1); if (minpos!= i) swap(v, minpos, i); private static void swap(comparable[] v, int i, int j) Comparable temp = v[i]; v[i] = v[j]; v[j] = temp; private static int findminpos(comparable[] v, int from, int to) int pos = from; Comparable min = v[from]; for (int i = from + 1; i <= to; i++) if (v[i].compareto(min) < 0) pos = i; min = v[i]; return pos; Ordinamento di oggetti Definito un algoritmo per ordinare un array di riferimenti Comparable, se vogliamo ordinare un array di oggetti BankAccount basta fare BankAccount[] v = new BankAccount[10]; // creazione dei singoli elementi dell array // ed eventuali modifiche allo stato // degli oggetti dell array ArrayAlgs.selectionSort(v); Dato che BankAccount realizza Comparable, l array di riferimenti viene convertito automaticamente Il metodo compareto Scrivere metodi compareto Il metodo compareto deve definire una relazione di ordine totale, ovvero deve avere queste proprietà Antisimmetrica: a.compareto(b) 0 b.compareto(a) 0 Riflessiva: a.compareto(a) = 0 Transitiva: a.compareto(b) 0 e b.compareto(c) 0 Implica a.compareto(c)<=0 a.compareto(b) può restituire qualsiasi valore negativo per segnalare che a precede b if (a.compareto(b) == -1) //errore logico! if (a.compareto(b) < 0) // giusto!

29 I metodi compareto e equals Una classe che implementa Comparable ha i metodi compareto (per implementare Comparable) equals (ereditato da Object) Il metodo compareto definito in una classe dovrebbe sempre essere consistente con il metodo equals: (e1.compareto((object)e2) == 0) dovrebbe sempre avere lo stesso valore booleano di e1.equals((object)e2) per ogni e1 e e2 della classe Il metodo equals in Object è: public boolean equals(object obj) return (this == obj); Quindi una classe che implementa Comparable dovrebbe sempre sovrascrivere equals Non sempre noi lo faremo 113 Comparable e Java >= 5.0 In seguito all introduzione in Java 5.0 dei tipi generici (che non vediamo), l utilizzo di Comparable induce il compilatore all emissione di strane (ma innocue) segnalazioni, che possono essere ignorate Note: MyClass.java uses unchecked or unsafe operations. Note: Recompile with -Xlint:unchecked for details. Compilando con l opzione nowarn si elimina l emissione delle segnalazioni javac nowarn MyClass.java 114 Riassunto: la classe ArrayAlgs Ecco la classe ArrayAlgorithms con tutti i metodi statici da noi sviluppati Tutti i metodi per l ordinamento e ricerca agiscono su array di tipo Comparable[ ] ed usano il metodo compareto per effettuare confronti tra oggetti binarysearch potrebbe usare il metodo equals per verificare l uguaglianza Ma per avere comportamenti consistenti le classi che implementano Comparable devono sovrascrivere equals Per ordinare (o cercare valori in) array numerici possiamo usare classi involucro (Integer, Double, ) Compilando questa classe vengono generati alcuni messaggi di warning, che ignoreremo 115 La classe ArrayAlgs public class ArrayAlgs // riportiamo solo i metodi per array di oggetti Comparable // i metodi per array di interi sono obsoleti // selectionsort per oggetti Comparable public static void selectionsort(comparable[] v, int vsize) for (int i = 0; i < vsize - 1; i++) int minpos = findminpos(v, i, vsize-1); if (minpos!= i) swap(v, minpos, i); private static void swap(comparable[] v, int i, int j) Comparable temp = v[i]; v[i] = v[j]; v[j] = temp; private static int findminpos(comparable[] v, int from, int to) int pos = from; Comparable min = v[from]; for (int i = from + 1; i <= to; i++) if (v[i].compareto(min) < 0) pos = i; min = v[i]; return pos; //continua 116

30 La classe ArrayAlgs //continua // mergesort per oggetti Comparable public static void mergesort(comparable[] v, int vsize) if (vsize < 2) return; // caso base int mid = vsize / 2; //dividiamo circa a meta Comparable[] left = new Comparable[mid]; Comparable[] right = new Comparable[vSize - mid]; System.arraycopy(v, 0, left, 0, mid); System.arraycopy(v, mid, right, 0, vsize-mid); mergesort(left, mid); // passi ricorsivi mergesort(right, vsize-mid); merge(v, left, right); private static void merge(comparable[] v, Comparable[] v1, Comparable[] v2) int i = 0, i1 = 0, i2 = 0; while (i1 < v1.length && i2 < v2.length) if (v1[i1].compareto(v2[i2]) < 0) v[i++] = v1[i1++]; La classe ArrayAlgs // ---- insertionsort per oggetti Comparable //continua public static void insertionsort(comparable[] v, int vsize) for (int i = 1; i < vsize; i++) Comparable temp = v[i]; //elemento da inserire int j; for (j = i; j > 0 && temp.compareto(v[j-1]) < 0; j--) v[j] = v[j-1]; v[j] = temp; // inserisci temp in posizione // ricerca (binaria) per oggetti Comparable public static int binarysearch(comparable[] v, int vsize, Comparable value) return binsearch(v, 0, vsize-1, value); private static int binsearch(comparable[] v, int from, int to, Comparable value) if (from > to) return -1;// el. non trovato int mid = (from + to) / 2; // circa in mezzo Comparable middle = v[mid]; if (middle.compareto(value) == 0) return mid; //trovato else if (middle.compareto(value) < 0) //cerca a destra return binsearch(v, mid + 1, to, value); else // cerca a sinistra return binsearch(v, from, mid - 1, value); else v[i++] = v2[i2++]; while (i1 < v1.length) v[i++] = v1[i1++]; while (i2 < v2.length) v[i++] = v2[i2++]; //continua Ordinamento e ricerca di libreria La libreria standard fornisce, per l ordinamento e la ricerca, alcuni metodi statici in java.util.arrays un metodo sort che ordina array di tutti i tipi fondamentali e array di Comparable String[] ar = new String[10]; Arrays.sort(ar); un metodo binarysearch che cerca un elemento in array di tutti i tipi fondamentali e in array di Comparable restituisce la posizione come numero intero