Chapter 11

Inheritance


Chapter Goals

Inheritance

An Inheritance Diagram


Adding a Subclass Method

public class SavingsAccount extends BankAccount 
{
public SavingsAccount(double rate)
{
interestRate = rate;
}

public void addInterest()
{
double interest = getBalance() * interestRate / 100;
deposit(interest);
}

private double interestRate;
}

Layout of a Subclass Object


Syntax 11.1: Inheritance

  class SubclassName extends SuperclassName
{
   methods
   instance fields

}

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.

Inheritance Hierarchies

A Part of the Hierarchy of Ancient Reptiles


A Part of the Hierarchy of Swing UI Components


Bank Account Hierarchy


Inheritance and Methods

Inheritance and Fields

CheckingAccount Class

Inherited Fields are Private

Invoking a Superclass Method

Syntax 11.2: Calling a Superclass Method

  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

Superclass Construction

public class CheckingAccount extends BankAccount 
{
public CheckingAccount(double initialBalance)
{
// construct superclass
super(initialBalance);
// initialize transaction count
transactionCount =0;
}
...
}

Syntax 11.3: Calling a Superclass Constructor

  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.

Converting from Subclasses to Superclasses

Variables of Different Types Refer to Same Object


Polymorphism

File AccountTest.java

1/**
2   This program tests the BankAccount class and
3   their subclasses. 
4*/
5 public class AccountTest
6{  
7   public static void main(String[] args)
8   {  
9      SavingsAccount momsSavings 
10         = new SavingsAccount(0.5);
11         
12      CheckingAccount harrysChecking
13         = new CheckingAccount(100);
14         
15      momsSavings.deposit(10000);
16      
17      momsSavings.transfer(harrysChecking, 2000);     
18      harrysChecking.withdraw(1500);
19      harrysChecking.withdraw(80);      
20
21      momsSavings.transfer(harrysChecking, 1000);
22      harrysChecking.withdraw(400);      
23
24      // simulate end of month
25      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}

File BankAccount.java

1/**
2   A bank account has a balance that can be changed by 
3   deposits and withdrawals.
4*/
5public class BankAccount
6{  
7   /**
8      Constructs a bank account with a zero balance
9   */
10   public BankAccount()
11   {  
12      balance = 0;
13   }
14
15   /**
16      Constructs a bank account with a given balance
17      @param initialBalance the initial balance
18   */
19   public BankAccount(double initialBalance)
20   {  
21      balance = initialBalance;
22   }
23 
24   /**
25      Deposits money into the bank account.
26      @param amount the amount to deposit
27   */
28   public void deposit(double amount) 
29   {  
30      balance = balance + amount;
31   }
32
33   /**
34      Withdraws money from the bank account.
35      @param amount the amount to withdraw
36   */
37   public void withdraw(double amount) 
38   {  
39      balance = balance - amount;
40   }
41
42   /**
43      Gets the current balance of the bank account.
44      @return the current balance
45   */
46   public double getBalance()
47   {  
48      return balance; 
49   }
50   
51   /**
52      Transfers money from the bank account to another account
53      @param other the other account
54      @param amount the amount to transfer
55   */
56   public void transfer(BankAccount other, double amount)
57   {  
58      withdraw(amount);
59      other.deposit(amount);
60   }
61
62   private double balance; 
63}

File CheckingAccount.java

1/**
2   A checking account that charges transaction fees.
3*/
4public class CheckingAccount extends BankAccount
5{  
6   /**
7      Constructs a checking account with a given balance
8      @param initialBalance the initial balance
9   */
10   public CheckingAccount(int initialBalance)
11   {  
12      // construct superclass
13      super(initialBalance);
14      
15      // initialize transaction count
16      transactionCount = 0; 
17   }
18
19   public void deposit(double amount) 
20   {  
21      transactionCount++;
22      // now add amount to balance 
23      super.deposit(amount); 
24   }
25   
26   public void withdraw(double amount) 
27   {  
28      transactionCount++;
29      // now subtract amount from balance 
30      super.withdraw(amount); 
31   }
32
33   /**
34      Deducts the accumulated fees and resets the
35      transaction count.
36   */
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}

File SavingsAccount.java

1/**
2   An account that earns interest at a fixed rate.
3*/
4public class SavingsAccount extends BankAccount
5{  
6   /**
7      Constructs a bank account with a given interest rate
8      @param rate the interest rate
9   */
10   public SavingsAccount(double rate) 
11   {  
12      interestRate = rate;
13   }
14
15   /**
16      Adds the earned interest to the account balance.
17   */
18   public void addInterest() 
19   {  
20      double interest = getBalance() * interestRate / 100;
21      deposit(interest); 
22   }
23
24   private double interestRate;
25}

Access Control Level

Recommended Access Levels

Object: The Cosmic Superclass

The Object Class is the Superclass of Every Java Class


Overriding the toString Method

Overriding the equals Method

Two References to Equal Objects


Two References to Same Object


Overriding the clone Method