Class 14: Equality Testing

Held Monday, September 18, 2000

Summary

Today we delve into issues of inheritance, polymorphism, overloading, and overriding by considering how one might write methods that compare objects for equality.

Notes

• As you may have noticed, I've rearranged this week's topics slightly.
• For tomorrow; Read G2: Java's Abstract Windowing Toolkit and G3: Java's AWT, Continued.
  • We'll probably concentrate on G3.
• Don't forget today's brown-bag lunch.
• Are there questions on exam 1?
  • I've made some changes to the exam after doing it myself.
  • I will give an example of an equals method that may help with PartC.

Overview

• Writing equals methods
• Type-specific
• More general
  • Variations

Writing equals methods

• Let's delve a little bit more into issues of overriding and polymorphism.
• Consider the equals method defined in the java.lang.Object class.
• The type signature is

  public boolean equals(Object other)
  

• It does not throw exceptions.
• Currently, equals returns true if and only if the two objects
• How might you rewrite it for the Fraction class?
• We'll start with a ``When does another Fraction equal this fraction?'' method.

  /**
   * Determine if another Fraction is equal to this fraction.
   * Pre: Both fractions are initialized.
   * Post: Returns true if both are equal in the sense that they
   *       have the same numerator and denominator.  (Not a true
   *       sense of equality, but the best I can come up with for
   *       now.)
   */
  public boolean equals(Fraction other) {
    return ( (this.numerator == other.numerator) 
             && (this.denominator == other.denominator) );
  } // equals(Fraction)
  

• Note that it has the same name, but a different parameter. This duplication is an example of overloading.
• We still need to consider overriding. When is another object equal to this fraction?
  • When it's a fraction and they're equal fractions.
  • When it's an integer and has the same value as this fraction.
  • ...
• You write ``is a'' with instanceof.
• You tell Java to treat something as a different class by prefixing it with the name of the class in parentheses.
• Here goes ...

  public boolean equals(Object other) {
    if (other instanceof Fraction) {
      return equals((Fraction) other);
    }
    else if (other instanceof Integer) {
      return ( (this.denominator == 1)
               && ((Integer) other).intValue() == this.numerator);
    }
    else {
      return false;
    }
  } // equals(Object)