capitolo 10 ereditarietà super - deifilira/fi/etc/ch10.itx4.pdf · 1 capitolo 10 ereditarietà...

1

Capitolo 10Ereditarietà

Fondamenti Informatica UNIPD 2007 2

Obiettivi

Imparare cos’è l’ereditarietàCapire come ereditare e sovrascrivere i metodi superclasse Invocare il costruttore della superclasse I controlli d’eccesso protected e packageLa superclasse Object e i metodi toStringe equals


Introduzione all’ereditarietà

Ereditarietàestendere classi aggiungendo metodi e campi

Es: conto di risparmio = Conto corrente bancario con interessi

class SavingsAccount extends BankAccount{

new methods new instance fields

}


Introduzione all’ereditarietàSavingsAccount automaticamente eredita

metodi e le istanze di BankAccount

Classe estesa = Superclasse (BankAccount),Classe che estende = Sottoclasse (Savings)

SavingsAccount collegeFund = new SavingsAccount(10);

// Savings account with 10% interest

collegeFund.deposit(500);

// OK to use BankAccount method with SavingsAccount object

2



Ereditare da una classe ≠ implementare interfaccia

la sottoclasse eredita comportamento e stato

Un vantaggio dell’ereditarietà è il riutilizzo di codice


Diagramma dell’ereditarietà

Ogni classe estende la classe Object direttamente o indirettamente



public class SavingsAccount extends BankAccount{

public SavingsAccount(double rate) {

interestRate = rate; } public void addInterest() {

double interest = getBalance() * interestRate / 100; deposit(interest);

}

private double interestRate; }

Sottoclasse specifica le istanze aggiunte, i metodi aggiunti, e i metodi modificati o riscritti



IncapsulamentoaddInterest chiama getBalancenon può aggiornare il campo balance della superclasse (xché il campo è private)

Nota che addInterest chiama getBalance senza specificare un parametro implicito (la chiamata si applica allo stesso oggetto)

3


Layout di un oggetto Sottoclasse

L’oggetto SavingsAccount eredita l’istanza di balance da BankAccount, e guadagna un’altra istanza: interestRate


Sintassi 10.1: Ereditarietà

class SubclassName extends SuperclassName{

methods instance fields

}


Sintassi 10.1: EreditarietàExample:public class SavingsAccount extends BankAccount {

public SavingsAccount(double rate) {

interestRate = rate; }

public void addInterest() {

double interest = getBalance() * interestRate / 100; deposit(interest);

} private double interestRate;

}

Purpose:To define a new class that inherits from an existing class, and define the methods and instance fields that are added in the new class.


Verifica

1. Quale campo istanza ha un oggetto della classe SavingsAccount?

2. Elencare i 4 metodi che puoi applicare all’oggetto SavingsAccount

3. Se la classe Manager estende la classe Employee, qual’è la Superclasse e quale la Sottoclasse?

4


Risposte

1. due istanze: balance e interestRate2. deposit, withdraw, getBalance, e

addInterest. 3. Manager è la Sottoclasse; Employee è

la Superclasse.


Gerarchie dell’ereditarietà

Un insieme di classi può formare una complessa gerarchia di ereditarietà


Gerarchie dell’ereditarietàes: Swing


Gerarchie dell’Ereditarietàes: gerarchia Swing

Superclasse JComponent ha i metodi getWidth, getHeightLa classe AbstractButton ha i metodi per impostare/prendere testo e icone

5


Una semplice gerarchia: es. conto corrente

Considera una banca che offre ai suoi clienti i seguenti tipi di conto:

1. Conto corrente: no interessi; poche transazioni gratuite al mese, alle successive transazioni hanno una piccola spesa

2. Conto risparmio: si guadagna l’interesse che viene composto mensilmente





Superclasse JComponent ha i metodi getWidth, getHeightLa classe AbstractButton ha i metodi per impostare/prendere testo e icone



Tutti i conti hanno il metodo getBalanceTutti i conti supportano i metodi deposit e withdraw, ma l’implementazione è diversa Al conto corrente serve il metodo deductFees; Al Conto risparmio serve il metodo addInterest

6


Verifica

4. Qual’è lo scopo della classe JTextComponent in Fig. 4?

5. Quale istanza dovremo aggiungere alla classe CheckingAccount?


Risposte

4. Per esprimere il comportamento comune del campo testo e delle componenti del testo

5. Ci serve un contatore che conti il numero di prelievi e depositi


Ereditarietà - metodi

Sovrascrivere un metodo: fornire una diversa implementazione del metodo che esiste nella Superclasse Deve avere la stessa firma (stesso nome e stessi tipi di parametri) Se è applicato a un oggetto di tipo Sottoclasse, il metodo sovrascritto viene eseguito



Continued…

Ereditare un metodo: Non fornire una diversa implementazione del metodo che esiste nella Superclasse Il metodo della Superclasse può venire applicato all’oggetto Sottoclasse

7



Aggiungere un metodo: Fornire un nuovo metodo che non esiste nella Superclasse Il nuovo metodo può essere applicato solo agli oggetti Sottoclasse


Ereditare campi d’istanza

Non si possono riscrivere campi Ereditare campi : tutti i campi della Superclasse vengono automaticamente ereditatiAggiungere campi: scrivere un nuovo campo che non esiste nella Superclasse


Ereditare campi d’istanza

E se definisci un nuovo campo d’istanza con lo stesso nome del campo della Superclasse?

Ogni oggetto avrebbe due istanze con lo stesso nomeI campi possono avere valori diversi Possibile ma estremamente indesiderabile


sovrascrivere deposit e withdraw per incrementare il contatore delle transazioni

public class CheckingAccount extends BankAccount{

public void deposit(double amount) {. . .} public void withdraw(double amount) {. . .} public void deductFees() {. . .} // new method private int transactionCount; // new instance field

}

Implementare la classe CheckingAccount

8


Ogni oggetto CheckingAccount ha due istanze: balance (ereditato da BankAccount) transactionCount (nuovo a CheckingAccount)



Puoi applicare 4 metodi all’oggetto CheckingAccount: getBalance() (ereditato da BankAccount) deposit(double amount) (sovrascrive il metodo di BankAccount) withdraw(double amount) (sovrascrive il metodo di BankAccount) deductFees() (nuovo a CheckingAccount)



Considera il metodo deposit di CheckingAccount

non può aggiungere amount a balancebalance è un campo private della

Superclasse

I campi ereditati sono privati

public void deposit(double amount) { transactionCount++; // now add amount to balance . . .

}


I campi ereditati sono privati

una Sottoclasse non ha accesso ai campi privati della sua Superclasse la Sottoclasse deve usare l’interfaccia

pubblica

9


Invocare un metodo Superclasse

Non si può chiamare deposit(amount)nel metodo deposit di CheckingAccountthis.deposit(amount)

Chiamerebbe lo stesso metodo (ricorsioneinfinita)invece, invoca il metodo della Superclassesuper.deposit(amount)


Invocare un metodo Superclasse

Ora chiama il metodo deposito della classe BankAccountCompleta il metodo:

public void deposit(double amount) {

transactionCount++; // Now add amount to balance super.deposit(amount);

}


super.methodName(parameters)

Example:public void deposit(double amount)

{transactionCount++;super.deposit(amount);

}

Purpose:To call a method of the superclass instead of the method of the current class

Sintassi 10.2: invocare un metodo Superclasse


Implementazione metodi rimanenti

public class CheckingAccount extends BankAccount{

. . . public void withdraw(double amount) {

transactionCount++; // Now subtract amount from balance super.withdraw(amount);

}

10


Implementazione metodi rimanenti

public void deductFees() {

if (transactionCount > FREE_TRANSACTIONS) {

double fees = TRANSACTION_FEE * (transactionCount - FREE_TRANSACTIONS);

super.withdraw(fees); } transactionCount = 0;

} . . . private static final int FREE_TRANSACTIONS = 3; private static final double TRANSACTION_FEE = 2.0;

}


Verifica

6. Perchè il metodo withdraw della classe CheckingAccount chiama super.withdraw?

7. Perchè il metodo deductFees imposta il contatore delle transazioni a zero?


Risposte

6. Gli serve per ridurre il saldo, e non può accedere al campo balance direttament

7. In modo che il contatore possa riflettere il numero di transazioni del mese seguente


Errori comuni: i campi istanza oscuri

public class CheckingAccount extends BankAccount { public void deposit(double amount) {

transactionCount++; balance = balance + amount;

} . . .

private double balance; // Don't }

una Sottoclasse non ha accesso al campo d’istanza privato della Superclasse Errore del principiante: “risolvere" questo problema aggiungendo un’altra istanza con lo stesso nome:

11


Errori comuni: i campi istanza oscuri

Ora il metodo deposit compila, ma non aggiorna il saldo corretto!


Costruttore della Sottoclasse

public class CheckingAccount extends BankAccount { public CheckingAccount(double initialBalance) {

// Construct superclasssuper(initialBalance); // Initialize transaction count transactionCount = 0;

} . . .

}

super segiuto dalle parentesi indica una chiamata al costruttore della Superclasse


Costruttore della Sottoclasse

deve essere la prima istruzione nel costruttore della Sottoclassese il costruttore della Sottoclasse non chiama il costruttore della Superclasse, viene usato il costruttore di default della Superclasse

costruttore di default senza parametri Se tutti i costruttori della Superclasse richiedono parametri, il compilatore dàerrore


Sintassi 10.1: chiamare il Costruttore della Sottoclasse

ClassName(parameters){

super(parameters);. . .

}

Example:public CheckingAccount(double initialBalance) {

super(initialBalance); transactionCount = 0;

}

Purpose:To invoke a constructor of the superclass. Note that this statement must be the first statement of the subclass constructor.

12


Verifica

8. Perchè il costruttore SavingsAccountnella Sezione 13.1 non chiama il costruttore della Superclasse?

9. Quando invochi un metodo Superclasse con la parola-chiave super, la chiamata deve essere la prima istruzione del metodo della Sottoclasse?


Risposte

8. Era pronto per usare il costruttore di default della Superclasse, che setta il saldo a zero.

9. No – è un requisito solo dei costruttori. Per esempio, il metodo SavingsAccount.deposit prima incremente il contatore della transazione, poi chiama il metodo della Superclasse.


Conversione di tipo fra sottoclasse e superclasse

I tre riferimenti a oggetti memorizzati in collegeFund, anAccount, e anObject si riferiscono tutti allo stesso oggetto di tipo SavingsAccount



La superclasse anAccount non conosce tutta la storia dell’oggetto a cui si riferisce:

Quando convertite un oggetto della sottoclasse in un oggetto di superclasse:

Il valore di riferimento stesso non cambia: si tratta dell’indirizzo di memoria che contiene l’oggetto.Ma,dopo la conversione si hanno minori informazioni sull’oggetto.

anAccount.deposit(1000); // OK anAccount.addInterest(); // No,non è un metodo della classe a cui appartiene anAccount

13



Perchè avere meno informazioni a proposito di un oggetto?

per riutilizzare codice che può elaborare oggetti della superclasse ma non oggetti della sottoclasse

Potete utilizzare questo metodo per trasferire denaro da ogni tipo di BankAccount

public void transfer(double amount, BankAccount other) {

withdraw(amount); other.deposit(amount);

}



Può darsi che abbiate bisogno di convertire un riferimento di superclasse in un riferimento di sottoclasse

Questo cast però può essere pericoloso: se vi sbagliate viene lanciata un’eccezione

BankAccount anAccount = (BankAccount) anObject;



L’operatore instanceoftesta se l’oggetto appartiene ad un particolare tipo

if (anObject instanceof BankAccount) {

BankAccount anAccount = (BankAccount) anObject; . . .

}


Syntax 10.4: L’operatore InstanceOf

object instanceof TypeName

Esempio:if (anObject instanceof BankAccount)

{ BankAccount anAccount = (BankAccount) anObject; . . .

}

Obiettivo:Restituisce true se oggetto è un esemplare di TypeName(o di uno dei suoi sottotipi); altrimenti restituisce false.

14


Verifica

10. Perchè il secondo parametro del metodo transfer deve essere di tipo BankAccount e non, per esempio, di tipo SavingsAccount?

11. Perchè non possiamo modificare il secondo parametro del metodo transferin modo che sia di tipo Object?


Risposte10. Noi vogliamo usare il metodo per tutti I generi

di bank accounts. Noi abbiamo utilizzato un parametro di tipo SavingsAccount, noi perciò non possiamo chiamare il metodo con un oggetto CheckingAccount .

11. Noi non possiamo invocare il metodo deposit di una variabile di tipo Object.


PolimorfismoIn Java il tipo di una variabile non determina completamente il tipo dell’oggetto a cui essa fa riferimento

Le chiamate al metodo sono determinate dal tipo reale dell’oggetto, non in base al tipo di riferimento dell’oggetto

BankAccount aBankAccount = new SavingsAccount(1000); // aBankAccount holds a reference to a SavingsAccount

BankAccount anAccount = new CheckingAccount(); anAccount.deposit(1000);

// Calls "deposit" from CheckingAccount


Polimorfismo

Il compilatore deve controllare che solo i metodi autorizzati siano stati invocati

Object anObject = new BankAccount(); anObject.deposit(1000); // Wrong!

15


PolimorfismoPolimorfismo

capacità di riferirsi agli oggetti di vario tipo variandone il comportamento

Realizzazione di un polimorfismo:

In relazione ai tipi di oggetti, vengono invocate versioni diverse dei withdraw e deposit

public void transfer(double amount, BankAccount other) { withdraw(amount); // abbreviazione: this.withdraw(amount) other.deposit(amount);

}


AccountTester.java01: /**02: Questo programma collauda la classe BankAccount e le sue03: sottoclassi.04: */05: public class AccountTester06: { 07: public static void main(String[] args)08: { 09: SavingsAccount momsSavings10: = new SavingsAccount(0.5);11:12: CheckingAccount harrysChecking13: = new CheckingAccount(100);14:15: momsSavings.deposit(10000);16:


AccountTester.java [2]

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: // Simulazione della fine del mese25: 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: }


BankAccount.java

01: /**02: Un conto bancario ha un saldo che può essere modificato03: con versamenti e prelievi.04: */05: public class BankAccount06: { 07: /**08: Costruisce un conto bancario con saldo uguale a zero.09: */10: public BankAccount()11: { 12: balance = 0;13: }14:15: /**16: Costruisce un conto bancario con un saldo assegnato.17: @param initialBalance il saldo iniziale18: */

16


BankAccount.java [2]19: public BankAccount(double initialBalance)20: { 21: balance = initialBalance;22: }23: 24: /**25: Versa denaro nel conto bancario.26: @param amount la somma da versare27: */28: public void deposit(double amount) 29: { 30: balance = balance + amount;31: }32: 33: /**34: Preleva denaro dal conto bancario.35: @param amount la somma da prelevare36: */


BankAccount.java [2]37: public void withdraw(double amount) 38: { 39: balance = balance - amount;40: }41: 42: /**43: Restituisce il valore del saldo del conto bancario.44: @return il saldo attuale45: */46: public double getBalance()47: { 48: return balance; 49: }50: 51: /**52: Trasferisce denaro dal conto a un altro conto53: @param amount la somma da trasferire54: @param other l’altro conto55: */


BankAccount.java [2]56: public void transfer(double amount, BankAccount other)57: { 58: withdraw(amount);59: other.deposit(amount);60: }61:62: private double balance; 63: }


CheckingAccount.java01: /**02: Un conto corrente che addebita commissioni per le03: transazioni. */04: public class CheckingAccount extends BankAccount05: { 06: /**07: Costruisce un conto corrente con un saldo assegnato.08: @param initialBalance il saldo iniziale09: */10: public CheckingAccount(double initialBalance)11: { 12: // costruisce la superclasse13: super(initialBalance);14:15: // azzerra il conteggio delle transazioni16: transactionCount = 0; 17: }18:

17


CheckingAccount.java[2]

19: public void deposit(double amount) 20: { 21: transactionCount++;22: // ora aggiungi amount al saldo23: super.deposit(amount); 24: }25:26: public void withdraw(double amount) 27: { 28: transactionCount++;29: // ora sottrai amount dal saldo30: super.withdraw(amount); 31: }32: 33: /**34: Sottrae le commissioni accumulate e azzerra il 35: relativo conteggio.36: */


CheckingAccount.java[3]

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: }


SavingsAccount.java01: /**02: Un conto bancario che matura interessi a un tasso fisso.03: */04: public class SavingsAccount extends BankAccount05: { 06: /**07: Costruisce un conto bancario con un tasso di

interesse assegnato.08: @param rate il tasso di interesse09: */10: public SavingsAccount(double rate) 11: { 12: interestRate = rate;13: }14: 15: /**16: aggiunge al saldo del conto gli interessi maturati.17: */


SavingsAccount.java[2]

18: public void addInterest() 19: { 20: double interest = getBalance() * interestRate / 100;21: deposit(interest); 22: }23: 24: private double interestRate;25: }

18


SavingsAccount.java[3]

Mom's savings balance = $7035.0 Harry's checking balance = $1116.0

Visualizza:


Verifica

12. Se a è una variabile di tipo BankAccount che contiene un riferimento non nullo, che informazioni abbiamo in merito all’oggetto a cui si riferisce?

13. Se a si riferisce a un conto corrente, che effetto ha l’invocazione seguente? a.transfer(1000, a)


Risposte

12. L’oggetto è un’istanza di BankAccount o di una delle sue sottoclassi.

13. Il bilancio di a è invariato, e la transazione count viene incrementata due volte.


Controllo di accesso

Java fornisce quattro livelli per il controllo di accesso a variabili, metodi e classi:public access

• Accesso dai metodi di tutte le classiprivate access

• Accesso solamente mediante i metodi della loro classe specifica

protected access • Accesso dai metodi di tutte le sottoclassi

Argomenti avanzati 10.3

19


Controllo di accesso

package access Default in assenza di un modificatore di accesso Si può accedere da tutte le classi dello stesso pacchettoBuona impostazione per le classi, ma estremamente infelice per i campi


Livelli di accesso raccomandato

Variabili di istanza e campi static: sono sempre private.Eccetto:

Le costanti pubbliche(public static final) sono utili e sicure.Qualche oggetto, come System.out, ha bisogno di essere accessibile a tutti i programmi (public)In rare occasioni, alcune classi in un pacchetto devono cooperare molto strettamente;può essere utile fornire ad alcune variabili il package access(accesso di pacchetto). Tuttavia le innerclasses( classi interne) sono la soluzione migliore.


Livelli di accesso raccomandato

Metodi: public o privateClassi o interfacce: public o package

La migliore alternativa al package access (accesso di pacchetto): inner classes (classi interne)

• In generale, l’inner classes (classi interne) non può essere pubblica (esiste qualche eccezione, ad es.Ellipse2D.Double)

Bisogna stare attenti ad utilizzare i metodi con il package access (generalmente i metodi dovrebbero essere public o private)


Verifica

14. Quale è una comune motivzione che porta alla definizione di campi di esemplare con package access(accesso di pacchetto)?

15. Se una classe dotata di costruttore pubblico ha il package access, che ne può costruire esemplari?

20


Risposte

14. Accidentalmente si dimentica il modificatore private.

15. Qualsiasi metodo di classe nello stesso pacchetto.


Object:La superclasse universale

Tutte le classi estendono automaticamente la classe Object


Object:La superclasse universale

I metodi più utilizzati: String toString()boolean equals(Object otherObject) Object clone()

Una buona idea è quella di sovrascriverequesti metodi nelle vostre classi


Sovrascrivere il metodo toString

Restituisce una stringa per ciascun oggetto Utile per trovare errori logici:

Rectangle box = new Rectangle(5, 10, 20, 30); String s = box.toString(); // Sets s to "java.awt.Rectangle[x=5,y=10,width=20,height=30]"

21



toString chiamato tutte le volte che concatenate una stringa con un oggetto.

Object.toString stampa il nome della classe seguito dal codice hash dell’oggetto

"box=" + box; // risulta: "box=java.awt.Rectangle[x=5,y=10,width=20,height=30]"

BankAccount momsSavings = new BankAccount(5000); String s = momsSavings.toString(); // s si riferisce a qualcosa di simile a

"BankAccount@d24606bf"



Per una informazione migliore dell’oggetto, si sovrascrive il metodo toString:

Questo sistema funziona meglio:

public String toString() {

return "BankAccount[balance=" + balance + "]"; }

BankAccount momsSavings = new BankAccount(5000); String s = momsSavings.toString(); // s si riferisce alla stringa "BankAccount[balance=5000]"


Sovrascrivere il metodo equals

equals confronta il contenuto di due oggetti:



L’opeatore == verifica se due riferimenti puntano allo stesso oggetto:

22


Sovrascrivere il metodo equalsDefinite il metodo equals per verificare se due

oggetti hanno lo stesso stato.Quando ridefinite il metodo, non vi è permesso modificare la firma del metodo stesso, dovete eseguire un cast sul parametro:public class Coin {

. . . public boolean equals(Object otherObject) {

Coin other = (Coin) otherObject; return name.equals(other.name) && value == other.value;

} . . . }



Dovreste sovrascrivere anche il metodo hashCode, in modo che oggetti uguali abbiano lo stesso codice hash.


Verifica

16. L’invocazione x.equals(x) deve sempre restituire true?

17. Si può realizzare il metodo equalsusando il metodo toString? E’ una cosa consigliabile?


Risposte

16. Certo,a meno che x non sia null. 17. Se al metodo toString ritorna una

stringa che descriva tutte le istanze, si invoca semplicemente il metodo toString nei parametri impliciti ed espliciti, e appare il risultato. Tuttavia, confrontare i campi di un oggetto risulta più efficiente di convertirli in stringhe.

23


Sovrascrivere il metodo clone

La copia di un riferimento a un oggetto fornisce semplicemente due riferimenti allo stesso oggetto

BankAccount account2 = account;



Creare copia oggetto



Definire il metodo clone significa realizzare un nuovo oggettoCome invocare il metodo clone:

Deve restituire un valore perché è di tipo Object

BankAccount clonedAccount = (BankAccount) account.clone();


Il metodo Object.clone

Crea sotto copie

24


Il metodo Object.clone

Non clona automaticamente tutti i sotto-oggetti Il metodo viene dichiarato protected; questo vi impedisce di chamarex.clone() se la classe a cui appartiene x non ha ridefinito clone come metodo publicBisogna sovrascrivere il metodo clone con cura

capitolo 10 ereditarietà super - deifilira/fi/etc/ch10.itx4.pdf · 1 capitolo 10 ereditarietà...

Documents