Often categorize concepts into hierarchies: Inheritance Hierarchies Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved

• Often categorize concepts into hierarchies:

Inheritance Hierarchies

Big Java by Cay HorstmannCopyright © 2009 by John Wiley & Sons. All rights reserved.


• Example: Different account types:

1. Checking account:

•No interest

•Small number of free transactions per month

•Charges transaction fee for additional transactions

2. Savings account:

•Earns interest that compounds monthly

• Superclass: BankAccount

• Subclasses: CheckingAccount & SavingsAccount



• Behavior of account classes:

• All support getBalance method

• Also support deposit and withdraw methods, but implementation details differ

• Checking account needs a method deductFees to deduct the monthly fees and to reset the transaction counter

• Checking account can override deposit and withdraw methods to count the transactions

• Savings account needs a method addInterest()





Syntax 10.1 Inheritance


• A subclass method overrides a superclass method if it has the same name and parameter types as a superclass method

• When such a method is applied to a subclass object, the overriding method is executed

Overriding Methods


• In subclass, specify additional instance variables, additional methods, and changed or overridden methods:

public class SavingsAccount extends BankAccount { private double interestRate;

public SavingsAccount(double rate) { // Constructor implementation } public void addInterest() { // method implementation } public void getBalance() { // overridden method implementation } }



• A subclass has no access to private instance variables of its superclass

• Encapsulation: addInterest calls getBalance rather than updating the balance variable of the superclass (variable is private)

• Note that addInterest calls getBalance without specifying an implicit parameter (the calls apply to the same object)

• Inheriting from a class differs from implementing an interface: the subclass inherits behavior from the superclass



• A subclass has no access to the private instance variables of the superclass: public class SavingsAccount extends BankAccount{ public void addInterest() { double interest = getBalance() * interestRate / 100; balance = balance + interest; // Error } . . .}

Common Error: Shadowing Instance Variables


• Beginner’s error: “solve” this problem by adding another instance variable with same name: public class SavingsAccount extends BankAccount{ private double balance; // Don’t public void addInterest() { double interest = getBalance() * interestRate / 100; balance = balance + interest; // Compiles but doesn’t // update the correct balance } . . .}



• Now the addInterest method compiles, but it doesn’t update the correct balance!



• Example: deposit and withdraw methods of the CheckingAccount class override the deposit and withdraw methods of the BankAccount class to handle transaction fees:

public class BankAccount{ . . . public void deposit(double amount) { . . . } public void withdraw(double amount) { . . . } public double getBalance() { . . . }}public class CheckingAccount extends BankAccount{ . . . public void deposit(double amount) { . . . } public void withdraw(double amount) { . . . } public void deductFees() { . . . }}

Overriding Methods


• Idea:

public class CheckingAccount extends BankAccount{ public void deposit(double amount) { transactionCount++; // Now add amount to balance using deposit() deposit(); // Not complete }}

• Won't work because compiler interpretsdeposit(amount);

asthis.deposit(amount);

which calls the method we are currently writing infinite ⇒recursion

Overriding Methods


• Use the super reserved word to call a method of the superclass:

public class CheckingAccount extends BankAccount{ public void deposit(double amount) { transactionCount++; // Now add amount to balance super.deposit(); }}

Overriding Methods


public void deductFees() { if (transactionCount > FREE_TRANSACTIONS) { double fees = TRANSACTION_FEE * (transactionCount - FREE_TRANSACTIONS); super.withdraw(fees); } transactionCount = 0; } . . .}

Overriding Methods (cont.)


Syntax 10.2 Calling a Superclass Method


• Constructors have special requirements for using super()…

Calling the super class constructor


Syntax 10.3 Calling a Superclass Constructor


• Superclass references don’t know the full story:

anAccount.deposit(1000); // OK anAccount.addInterest(); // No--not a method of the class to which anAccount// belongs

• Why would anyone want to know less about an object? • Reuse code that knows about the superclass but not the subclass:

public void transfer(double amount, BankAccount other){ withdraw(amount); other.deposit(amount);}

Can be used to transfer money from any type of BankAccount

Converting Between Subclass and Superclass Types


Syntax 10.4 The instanceof Operator


How to 10.1: Inheritance Hierarchy


• Type of a variable doesn’t completely determine type of object to which it refers:

Question q1 = new NumericQuestion();q1.display();

Question q2 = new FreeResponseQuestion();q2.display();

Which display method is called?

• Dynamic method lookup: When the virtual machine calls an instance method, it locates the method of the implicit parameter's class

• Also called Dynamic method invocation

Polymorphism and Inheritance


• Polymorphism: Ability to treat objects with differences in behavior in a uniform way

• The method call

display();

is a shortcut for

this.display();

• this can refer to a Question or a subclass object


ChoiceQuestion q1 = new ChoiceQuestion();q1.display();MultiChoiceQuestion q2 = new MultiChoiceQuestion();q2.display();


• Recall AnimalList with all dogs, cats, rabbits, etc. calling sleep()

• If a subclass implements a method that is in a superclass, such as sleep(), the sublcass overrides the super class method

• Dynamic lookup (dynamic invocation) occurs to determine which method to call

• To get both the subclass method and the super class method be invoked:

sleep()super.sleep()



• Recall AnimalList with all dogs, cats, rabbits, etc. calling sleep()

• If a subclass implements a method that is in a superclass, such as sleep(), the sublcass overrides the super class method

• Dynamic lookup (dynamic invocation) occurs to determine which method to call

• To get both the subclass method and the super class method be invoked:

sleep()super.sleep()



• If a subclass does not implement a method that is invoked, the compiler traverses up the hierarchy to find the closest one


mChoiceQ.display();

display()

display()

display()


• All classes defined without an explicit extends clause automatically extend Object:

Object: The Cosmic Superclass


Object: The Cosmic Superclass

• Most useful methods:

• String toString()

• boolean equals(Object otherObject)

• Good idea to override these methods in your classes

Documents

Often categorize concepts into hierarchies: Inheritance Hierarchies Big Java by Cay Horstmann Copyright © 2009 by John Wiley & Sons. All rights reserved