CS 46B - Lecture 3

Cay S. Horstmann

Pre-class reading

• Sections 10.1 - 10.4
• Did you do the quiz?

Plagiarism

• When you submit work, it must be your intellectual creation
• Can you copy and paste?
  • Always ok if it is from the problem statement or the textbook
  • Otherwise, you must attribute the source
• You can discuss your work with others
• You can post excerpts on a public discussion forum for critique
• Don't email code—you don't know what the recipient will do with it
  • If I find plagiarism, I don't play Sherlock Holmes to find who wrote it—I report both

Inheritance Basics

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

  

Lecture 3 Clicker Question 1

Which of the following statements is true?

1. BankAccount is a subclass of SavingsAccount
2. The SavingsAccount method overrides the deposit method of BankAccount
3. The SavingsAccount method inherits the addInterest method of BankAccount
4. The SavingsAccount method inherits the getBalance method of CheckingAccount

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

• Same name, same parameters, compatible return type

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

• Which one gets called?

  BankAccount myAccount = ...
  myAccount.withdraw(1000);

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

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 = ...
  myAccount.transfer(1000, anotherAccount);

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)

Lecture 3 Clicker Question 2

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

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

Lecture 3 Clicker Question 3

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.

Lab

• Still finishing Lab 1
• You will work with a buddy
• Buddy list is on schedule page
• No buddy? Come to the front of the room
• One of you (driver) fusses with the code, the other (scribe) types up answers
• Switch roles each class meeting
• Submit lab work to Desire2Learn