CS 46B - Lecture 2

Cay S. Horstmann

Pre-class reading

• Sections 9.3 - 9.5, Special Topics 9.1, 9.2 and How To 9.1
• Did you do the quiz?

Inheritance Basics

• Superclass, subclass
• extends
• Add instance variables, methods to subclass

  

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; // Doesn't work 
     } 
     . . . 
  }

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

• If you are not satisfied with the behavior of an inherited method,
  • You override it by specifying a new implementation in the subclass.
• An overriding method can extend or replace the functionality of the superclass method.
• Example: The display method of the ChoiceQuestion class
  • Displays the question text (like the superclass method)
  • Also display the answer choices.
• You don't need to touch the superclass!
  • See this Piazza conversation

Overriding Methods

• Problem: ChoiceQuestion's display method can’t access the text variable of the superclass directly because it is private.
• Solution: It can call the display method of the superclass, by using the reserved word super

  public void display()
  {
     // Display the question text
     super.display(); // OK
     // Display the answer choices
     . . .
  }

• super is a reserved word that forces execution of the superclass method.

Polymorphism

• Override method with same name, same parameters, compatible return type

  public class Question 
  {  
     . . . 
     public void display() { . . . } 
  } 
  
  public class ChoiceQuestion extends Question
  {  
     . . . 
     public void display() { . . . } 
  }

• Which one gets called?

  Question q = ...
  q.display();

  
  • Depends on actual type of object
  • Called “polymorphism”

Common Error: Accidental Overloading

• Overloading: when two methods have the same name but different parameter types.
• Overriding: when a subclass method provides an implementation of a superclass method whose parameter variables have the same types.
• When overriding a method, the types of the parameter variables must match exactly.
• For example,

  public class ChoiceQuestion extends Question
  {
     void display(String title) { ... }
     ...
  }
  

  does not override

  public class Question
  {
     void display() { ... }
     ...
  }

Lecture 2 Clicker Question 1

Suppose we define

public class CheckingAccount extends BankAccount
{
   public void withdraw(double amount, String purpose)
   {
      super.withdraw(amount);
      System.out.printf("Withdrawing $%.2f for %s\n", amount, purpose);
   }
}

What does this code snippet print?

BankAccount b = new CheckingAccount();
b.deposit(1000);
b.withdraw(100, "cell phone");

1. Withdrawing $100.00 for cell phone
2. Balance: $900.00
3. The code snippet compiles and prints nothing
4. The code snippet does not compile

Calling super

• Common to extend superclass behavior

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

• That's a recursive call this.deposit(amount)
• Solution: super.deposit(amount)

Superclass Construction

• Easy case: Superclass has no-arg constructor
• If you must invoke constructor with args, use super
• Must be first statement in subclass constructor

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

• super(...) calls superclass constructor, super.method(...) calls superclass method

Syntax 9.3 Constructor with Superclass Initializer

Lecture 2 Clicker Question 2

Why does the deposit method of the CheckingAccount class call super.deposit?

1. It needs to invoke the superclass constructor
2. Whenever you override a method, you must call super in order to avoid recursion
3. Every method that overrides another method must have a call to super as the first statement
4. It needs to update the balance, and it cannot access the balance variable directly.

Polymorphic Self Calls

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

• Which withdraw gets called?
• It's this.withdraw(amount)
• Depends on actual type of this
• Depends on caller

  BankAccount myAccount = new CheckingAccount();
  myAccount.transfer(1000, anotherAccount);

Lecture 2 Clicker Question 3

class A { 
   void print(String s) { System.out.print(s); }
   void f() { print("f"); g(); } 
   void g() { print("g"); }
}
class B extends A {
   void f() { print("f"); super.f(); }
   void g() { h(); }
   void h() { print("h"); }
}

A a = new B(); 
a.f(); // What does it print?

1. fg
2. ffg
3. ffh
4. None of the above

Object: The Cosmic Superclass

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

Overriding the toString Method

• Returns a string representation of the object
• Useful for debugging:

  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]"

• toString is called whenever you concatenate a string with an object:

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

• Object.toString prints class name and the hash code of the object:

  BankAccount momsSavings = new BankAccount(5000);
  String s = momsSavings.toString();
  // Sets s to something like "BankAccount@d24606bf"

• To provide a nicer representation of an object, override toString:

  public String toString()
  {
     return "BankAccount[balance=" + balance + "]";
  }

toString and Inheritance

• In superclass, print class name

  public class BankAccount
  {
     public String toString()
     {
        return getClass().getName() + "[balance=" + balance + "]";
     }
  }

• In subclass, call super.toString()

• public class SavingsAccount
  {
     public String toString()
     {
        return super.toString() + "[interestRate=" + interestRate + "]";
     }
  }

Lecture 2 Clicker Question 4

BankAccount acct = new SavingsAccount(0.5);
System.out.println(acct);

What does it print?

1. BankAccount[balance=0.0]
2. SavingsAccount[balance=0.0]
3. SavingsAccount[balance=0.0, interestRate=0.5]
4. SavingsAccount[balance=0.0][interestRate=0.5]

Overriding the equals Method

• equals tests for same contents:

  if (coin1.equals(coin2)) . . . 
     // Contents are the same

• == tests for references to the same object:

  if (coin1 == coin2) . . . 
     // Objects are the same

• Useful for locating elements in collection
  • ArrayList.contains calls equals

Overriding the equals Method

• Cannot change parameter type; use a cast instead:

  public class Coin
  {
     . . .
     public boolean equals(Object otherObject)
     {
        Coin other = (Coin) otherObject;
        return name.equals(other.name) && value == other.value;
     }
  }

Lecture 2 Clicker Question 5

public class CollectibleCoin extends Coin
{
   . . .
   public boolean equals(Object otherObject)
   {
      CollectibleCoin other = (CollectibleCoin) otherObject;
      return getName().equals(other.getName()) && getValue == other.getValue()
         && year == other.getYear;
   }
}

Coin c1 = new Coin("quarter", 0.25);
Coin c2 = new CollectibleCoin("quarter", 0.25, 1993);

What do c1.equals(c2) and c2.equals(c1) return?

1. Both return true
2. Both return false
3. The first one returns true, the second one returns false
4. The first one returns true, the second one throws an exception

Equals and Inheritance

• In superclass, check for equality of classes

  public class Coin
  {
     public boolean equals(Object otherObject)
     {
        if (getClass() != otherObject.getClass()) return false;
        ...
     }
  }

• In subclass, call super.equals

  public class CollectibleCoin extends Coin
  {
     public boolean equals(Object otherObject)
     {
        if (!super.equals(otherObject)) return false;
        ...
     }
  }

Before Next Class

• Read sections 10.1 - 10.2, Worked Example 10.1
• Make sure to do the quiz
• Friday lab starts this week
• Homework 1 final