JETT Workshop - Object-Oriented Programming

(Example code and figures from Computing Concepts with Java Essentials, 3rd edition, by Cay Horstmann.
Visit www.wiley.com/college/horstmann for information on the current edition of this excellent text.)

from the AP CS Java Subset

Students are expected to understand that conversion from a subclass reference to a superclass reference is legal and does not require a cast.
Class casts (generally from Object to another class) are part of the AP Java subset, to enable the use of generic collections
- for example: Person p = (Person)people.get(i);

Converting from a Subclass to a Superclass

it is legal to convert a subclass reference to a superclass reference

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

Converting from a Superclass to a Subclass

conversion from a superclass reference to a subclass reference requires a cast

SavingsAccount collegeFund = new SavingsAccount(10);
BankAccount anAccount = collegeFund;
...
SavingsAccount active = (SavingsAccount) anAccount;

there are classes in the API that store collections of Object references
to use these references, you must cast them to the appropriate type

Invoking a Method

when invoking a method
- the type of the object variable determines what methods are defined
- the method must be defined in the class of the object variable, or one of its superclasses
  collegeFund.addInterest(); // OK anAccount.addInterest(); // not legal
on the other hand
- the method that actually gets called depends on the actual type of the object being referred to
- this is polymorphism
  anAccount.deposit(); // SavingsAccount deposit method invoked
  - anAccount is type BankAccount
  - BankAccount has a deposit method
  - the object anAccount refers to is type SavingsAccount
  - SavingsAccount extends BankAccount and overrides the deposit method
  - thus the deposit method in SavingsAccount is invoked, instead of the one in BankAccount

Using Polymorphism

polymorphism is one of the most powerful features of OO
it allows us you to handle many types of objects in a uniform way

consider this method we can add to the BankAccount class

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

this will work with any kind of bank account (plain, checking, or savings)

when invoked, a subclass object reference passed in is converted to the superclass reference called other

CheckingAccount harrysChecking = ...;
SavingsAccount momsAccount = ...;
momsAccount.transfer(1000, harrysChecking);

in the transfer method, the actual type of the object the variable other refers to is CheckingAccount
CheckingAccount overrides the deposit method
thus, polymorphism ensures that the CheckingAccount deposit method is invoked for
other.deposit(amount);

The Object Class

see the AP CS Reference Materials
all classes extend Object by default - the Object class is the superclass of every Java class
Object defines some generally useful methods:
- String toString( )
- boolean equals(Object otherObject)
- and some others

Overriding the toString Method

toString( ) should return a string representation of the object contents
very useful for debugging

System.out.println( ) calls the toString( ) method on any object variables passed to it

Rectangle box = new Rectangle(5, 10, 20, 30);
System.out.println(box);

prints out:

java.awt.Rectangle[x=5,y=10,width=20,height=30]

the concatenation operator calls the toString( ) method too

Rectangle box = new Rectangle(5, 10, 20, 30);
String info = "box has " + box;
System.out.println(info);

prints out:

box has java.awt.Rectangle[x=5,y=10,width=20,height=30]

your class inherits the toString( ) method provided by the Object class

if you don't override it, you get the default behavior

Object.toString prints class name and object address

BankAccount vacationFund = ...;
System.out.println(vacationFund);

prints out something like:

BankAccount@d2460bf

to override toString( ), implement the toString( ) method in your class

public class BankAccount
{  ...

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

Overriding the equals Method

given two object variables

Coin coin1 = new ...;
Coin coin2 = coin1;
...
if (coin1 == coin2)
   System.out.println("same location");

using == only test for equal location

assuming that a valid equals( ) method is defined for the class, then equals( ) tests for equal content

Coin coin1 = new ...;
Coin coin2 = new ...;
...
if (coin1.equals(coin2))
   System.out.println("same content");

if you want equals( ) to test your objects for equal content, you must override the equals( ) method

in order to use the object variable to access instance variables, it must be cast to the subclass type

public class Coin
{  ...

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