Using a superclass reference

• Which method is called is based on the type of the object not the reference

  BankAccount account = new CheckingAccout(1000);
  account.deposit(200); //calls the deposit method of CheckingAccount

  account = new BankAccount()
  account.deposit(200); //deposit method of BankAccount

  account = new SavingsAccount()
  account.deposit(200); //deposit method of SavingsAccount

  account = new Rectangle(); // error
  //Rectangle is not a BankAccount
  

• An example of polymorphism

Converting Between Subclass and Superclass

• You can always assign a subclass object to a superclass reference

  Object anObject;
  BankAccount anAccount;
  SavingsAccount collegeFund;
  
  
  
  collegeFund = new SavingsAccount(10);
  anAccount = collegeFund;
  anObject = collegeFund;

• Three references - one object
• . . .

Converting Between Subclass and Superclass

• superclass reference can only access the superclass methods
• anAccount is a BankAccount reference
• anAccount can only access BankAccount methods
  • deposit is a BankAccount method

    anAccount.deposit(1000); // OK

• anAccount can not access SavingsAccount methods
  • addInterest is a SavingsAccount method - not a BankAccount method

    anAccount.addInterest(); // No

Converting Between Subclass and Superclass

Often useful in processing different subclasses of a superclass

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

• This method can transfer money from any type of BankAccount
• other could be a BankAcount, a SavingsAccount, a CheckingAccount, ...
• this method works because we are only usng BankAccount methods

Class Question # 1

Why was the second parameter of the transfer method of type BankAccount?

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

1. That's an error—it should have been of type SavingsAccount
2. That's an error—it should have been of type Object
3. So that the method can be called with SavingsAccount and CheckingAccount objects
4. So that the method can be called with objects of any subclass of BankAccount

Follow-up Question

Why can't we change the second parameter of the transfer method to the type Object?

Getting a subclass reference

• Sometimes we know that the superclass reference actually points to a subclass object
• To use the subclass methods, we need a subclass reference

  CheckingAccount aChecking = anAccount; //compile error

• Cast to tell the compiler you know what you are doing

  CheckingAccount aChecking = (CheckingAccount)anAccount; 

  • Promises the compiler that anAccount will reference a CheckingAccount object at runtime
  • If you are wrong, an exception is thrown

Getting a subclass reference

• Casting is dangerous
• Prevent execptions with instanceof operator

  if (anAccount instanceof CheckingAccount)
  {
     CheckingAccount aChecking = (CheckingAccount)anAccount;
     . . .
  }

• . . .

The mother of all classes: Object

• All classes defined without an explicit extends clause automatically extend Object:
• Every class is a subclass of Object
• BankAccount is a subclass of Object and inherits all its methods
• CheckingAccount is a subclass of BankAccount and so is also a subclass of Object

Look at Object in the Java API

http://docs.oracle.com/javase/7/docs/api/

 

Object's methods

• All objects inherit these methods
• The two we will talk about
  • equals
  • toString
• Object provides very general implementations of these
  • Most classes should override equals and toString to provide meaningful implementation

The toString method*

• Returns a string representation of the object
• 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
• Rectangle overrides toString so that:

  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]

Override the toString method

• To provide a nicer representation of an object, override
• Must have the same name and number and type of parameters
  • Name: toString, no parameters, return type of String
• To override Object's toString in BankAccount:

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

• Include the class name followed by the names and values of the parameters in braces

A better toString

• Rather than hardcode the class name, use getClass().getName()

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

A better toString

• In subclass, call super.toString() and then concatenate the names and values of new instance variables

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

Objects equals method*

• == tests for references to the same object:

  if (coin1 == coin2) . . . 
      

  • Are objects the same?

• Object's equals method uses ==

  if (coin1.equals(coin2)) . . . 
     

  • Are objects the same?
• Subclasses should override Object's equals method to test for the same content

Overriding equals

• Object's equals method has this signature

  public boolean equals(Object otherObject)

• We must use the same signature to override the method

  public class Coin
  {
     . . .
     public boolean equals(Object otherObject)
     {
        ...
     }
  }

Overriding equals in Coin class

• The equals method takes an parameter of type Object
  • even though it is really a Coin
• To be able to access Coin methods and variables, we must cast to a Coin
  • and then test the instance variables for equality

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

Overriding equals

• Now our equals tests for same contents:
  
  • coin1.equals(coin2) is true
  • coin1 == coin2 is false. They are not the same exact Coin

Overriding equals

• == still tests for the same identical objects
  
  • coin1 == coin2 is true

Class question #2

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

Fixing the problem

But that is not logical.

To fix the problem, equals should test that objects are of the same class

• equals for Coin

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

• equals for CollectableCoin

  public class CollectableCoin
  {
     public boolean equals(Object otherObject)
     {
        if (!super.equals(otherObject)) return false;
        //...cast and test new variables
     }
  }

• Now coin1.equals(coin2) is false and coin2.equals(coin1) is false

Abstract classes

Special topic 10.1

• Sometimes every subclass of a class will need to implement a particular method
  • but every subclass will need to do something different
• We create an abstract class and declare the method abstract

Animal Class Example

• Think of a heirarchy of animal classes
• All animals have certain properties
  • averageLifeSpan is one example
• All will need a method to get the averageLifeSpan
  • can be the same for all animals
• All animals need a method eat()
  • But every animal will eat different things

Abstract Method

• Has a header but no implementation
  • Just like in an interface

  public abstract returnType someMethod();

• Any class containing an abstract method must be declared abstract
• Declare the animal class abstract and provide an abstract eat() method

AbstractAnimal

By convention, abstract class usually start withthe word abstract in Java

public abstract class AbstractAnimal

{
   private int averageLifeSpan;
   
   public AbstractAnimal(int span) {averageLifeSpan = span; }
   public int getAverageLifeSpan() {return averageLifeSpan; }
   
   public abstract String eats();
}

• Now every subclass must either implement a concrete eats method
  • or be declared abstract

 

Concrete subclass

public class Cat
{
   public Cat(int span)
   {
      super(span);
   }
   
   public String eats()
   {
      return "mice";
   }
}

• Cat overrides the abstract eats method so it is a concrete class

Abstract vs Concrete class

• Can not instantiate an abstract class

  new AbstractAnimal(); //illegal

• Can declare an object reference variable of the abstract class type
  • and assign an object of a concrete soubclass to it

  Cat corky = new Cat(20);
  AbstractAnimal myAnimal; //legal
  myAnimal = corky; //legal
  

Abstract class vs interface

More about Java.

• Both abstract classes and interfaces
  • can have abstract methods
  • can have constants
• Only an abstract class can have
  • concrete methods
  • variables