Class 13: Object Basics (2)

Held: Friday, 16 September 2005

Summary: Today we continue our basic study of classes, focusing on the design of a particular class.

Related Pages:

• Previous EBoard.
• EBoard.
• Sample Code.

Assignments

• Read Conditional Evaluation in Java in Espresso.
• Begin homework 2: Basics of class design.

Notes:

• Monday's reading won't be available until sometime this evening.

Overview:

• Writing methods.
• Kinds of classes.
• Standard methods.
• Class fields and methods.

Review

• Some classes describe objects.
• Such classes typically have five parts:
  • Fields, which describe individual objects,
  • Constructors, which provide the instructions for building those objects (often by assigning initial values to those field),
  • Methods, which provide instructions for the capabilities of those objects,
  • Class fields, which store shared information for the class, and
  • Class methods, which provide object-independent capabilities for the class.
• Fields have the form

  protection type name;
  

• Constructors have the form

  protection NameOfClass(parameters)
  {
  } // NameOfClass(types-of-parameters)
  

Methods

• The things you called functions in Scheme we call methods in Java.
• There are typically 6 parts to a method declaration.
  • A comment that describes the purpose of the method.
  • The protection level of the method (typically public).
  • The type of value the method returns. You must use void when a method doesn't return anything.
  • The name of the method.
  • The parameters of the method.
  • The body of the method.
• We tend to classify methods as observers and modifiers.
  • Observers extract a value from the object without changing the object.
  • Mutators change the object.
• The bodies of methods provide a series of instructions, much like the series of instructions you've written for main classes.
• We'll do some examples for our Vector2D class.

Detour: Three Kinds of Classes

• Although I haven't mentioned it explicitly, Java programmers use classes for a number of reasons. I typically classify these uses as template classes, main classes, and utility classes.
• Template classes provide templates for creating new objects.
  • Template classes are the most common classes.
• Main classes provide a main method. You can think of the main method as a combination of the script and directory of a play. This method creates the objects that form the initial actors of the play that is your program. It then tells them what to do.
• Utility classes (which you haven't really encountered yet) provide methods for manipulating other objects. These methods are primarily class/static methods.
• Some classes are a hybrid of these kinds of classes.

Standard Methods

• There are a number of methods that most template classes provide.
• You may have already encountered one such method, toString.
• Why have such standard methods? Because we can rely on them elsewhere.
• Some methods are implicitly there for every class (toString, equals, etc.)
• Some you state are there by indicating that your template class implements a particular interface.

The Equals Method

• One simple method is equals, which you use to determine whether one object is "naturally" the same as another object.
• You first have a responsibility to determine what "naturally" means.
  • Are two Vec2D's the same if they have the same X and Y coordinate, but one is a Polar and one is a Point?
  • Are two Polars the same if their radiuses are within 1/1000 of each other and their angles are also within 1/1000 of each other?
• The standard signature for the equals method is

  public boolean equals(Object other)
  

• Note that it is somewhat difficult to compare a specific object to a general object.
• The solution? You can cast the object to another type. For example

  Vec2D ovec = (Vec2D) other;
  

• What happens if the cast fails? Right now, your program crashes.
• What's the solution? You can check whether the other object is in the appropriate class with the instanceof operation

  if (other instanceof Vec2D) {
     Vec2D ovec = (Vec2D) other;
     ...
  }
  else {
     return false;
  }
  

Comparing objects with compareTo

• The compareTo method is a more general form of comparison.
• This method has the signature

  public boolean compareTo(Object other)
  

• If you write the compareTo method, you should indicate that your template class implements Comparable, as in

  public class ClassName
    implements Comparable
  {
    // ...
  } // class ClassName
  

• compareTo returns one of three kinds of values
  • a negative number, if the object that runs the compareTo method naturally preceeds the parameter object
  • zero, if the comparing object is naturally the same as the parameter object
  • a positive number, if the comparating object naturally follows the parameter object
• What should you do if the parameter object has no natural relationship? Give up.
  • We'll learn more about giving up in a few days.

The clone Method

• The clone method makes another copy of the current object.
• It is most useful for mutable objects, since it lets you make a copy of the current state of an object before changing the object.
• If you write the clone method, you should indicate that your mold class implements Cloneable.

  public class ClassName
    implements Cloneable
  {
    // ...
  } // class ClassName
  

• If you include both clone and compareTo, you must write

  public class ClassName
    implements Cloneable, Comparable
  {
    // ...
  } // class ClassName
  

• The signature of clone is

  public Object clone()
  

The hashCode Method

• The last of the standard methods is somewhat strange. The hashCode method returns some integer that represents this object.
• Different objects in the same class should be likely to have different numbers.
• Since there are often more objects in a class than valid integers, different objects can have the same number.
• Two equal objects should have the same number.
• We'll learn more details and make use of the hashCode method in the second half of the semester, but I'd like you to start including it in your classes now.

Class Fields and Methods

• Class fields and methods look almost exactly like object fields and methods except that you precede their declaration with the keyword static.
• You can also initialize class fields when you declare them.
• For example, if you want your class to keep track of how many objects it has created, you might write something like the following

  static long created = 0;
  
  ...
  public ClassName(parameters)
  {
    created = created + 1;
    ...
  }
  ...
  /**
   * Determine how many objects have been created by this class
   * in this session.
   */
  public static int productivity()
  {
    return created;
  } // int productivity()
  
  /**
   * Reset the count of objects created by the class.
   */
  public static int reset()
  {
    created = 0;
  } // reset()