CS 46A - Lecture 25

Pre-class reading

• Sections 10.1 - 10.3

Inheritance Hierarchies

• Often categorize concepts into hierarchies:
  

Inheritance Hierarchies

• Set of classes can form an inheritance hierarchy
  • Classes representing the most general concepts are near the root, more specialized classes towards the branches:

  

Inheritance Hierarchies

• Superclass: more general class
• Subclass: more specialized class that inherits from the superclass
  • Example: JPanel is a subclass of JComponent

Inheritance Hierarchies

• 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

Inheritance Hierarchies

• 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 must override deposit and withdraw methods to count the transactions
• 

Lecture 25 Clicker Question 1

Should we place the addInterest method in the BankAccount class?

1. No, not all bank accounts earn interest.
2. No, it would be a syntax error to put it there because the SavingsAccount subclass has an addInterest method.
3. It would be better to put it there so that checking accounts can earn interest
4. It would be better to put it there so that we can later add time deposit accounts that earn interest

Inheritance Hierarchies

• Inheritance is a mechanism for extending existing classes by adding instance variables and methods:

  public class SavingsAccount extends BankAccount 
  { 
     added instance variables 
     new methods 
  }

• A subclass inherits the methods of its superclass:

  SavingsAccount collegeFund = new SavingsAccount(10);
  // Savings account with 10% interest
  collegeFund.deposit(500);
  // OK to use BankAccount method with SavingsAccount object

Inheritance Hierarchies

• In subclass, specify added instance variables and 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
     }
  }

Inheritance Hierarchies

• Instance variables declared in the superclass are present in subclass objects
• SavingsAccount object inherits the balance instance variable from BankAccount, and gains one additional instance variable, interestRate:
  

Inheritance Hierarchies

• Implement the new addInterest method:

  public class SavingsAccount extends BankAccount 
  {  
     private double interestRate; 
     
     public SavingsAccount(double rate) 
     {  
        interestRate = rate; 
     } 
     
     public void addInterest() 
     {  
        double interest = getBalance() * interestRate / 100; 
        deposit(interest); 
     } 
  }

Inheritance Hierarchies

• 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

Syntax 10.1 Inheritance

Lecture 25 Clicker Question 2

Which instance variables does an object of class SavingsAccount have?

1. It has no instance variables
2. interestRate
3. interestRate and balance
4. interestRate, balance, and interest

Lecture 25 Clicker Question 3

Which methods that you can apply to SavingsAccount objects?

1. deposit and withdraw, but not addInterest
2. deposit and withdraw, but not getBalance
3. addInterest but not deposit, withdraw, or getBalance
4. deposit, withdraw, getBalance, and addInterest

Common Error: Shadowing Instance Variables

• 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!
  

Overriding Methods

• 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
• 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

• Problem: Overriding method deposit can't simply add amount to balance:

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

• If you want to modify a private superclass instance variable, you must use a public method of the superclass
• deposit method of CheckingAccount must invoke the deposit method of BankAccount

Overriding Methods

• Idea:

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

• Won't work because compiler interprets

  deposit(amount);

  as

  this.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(amount); 
     } 
     . . . 
  }

Overriding Methods

• Remaining methods of CheckingAccount also invoke a superclass method:

  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 withdraw(double amount) 
     {  
        transactionCount++; 
        // Now subtract amount from balance 
        super.withdraw(amount); 
     } 
     public void deductFees() 
     {  
        if (transactionCount > FREE_TRANSACTIONS) 
        {  
           double fees = TRANSACTION_FEE * (transactionCount - FREE_TRANSACTIONS); 
           super.withdraw(fees); 
        } 
        transactionCount = 0; 
     } 
     . . . 
  } 

Syntax 10.2 Calling a Superclass Method