Class 11: Object Basics (2)

Held: Wednesday, February 9, 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.

Overview:

• Constructor details.
• Kinds of classes.
• Standard methods.

Constructors, Revisited

• Constructors are special methods used to create new objects within the class. They are much like methods except
  • Their "name" and "type" are combined into the name of the class.
  • There is no explicit return statement.
• The form is therefore

  protection ClassName(parameters)
  {
    body
  } // ClassName(parameters)
  

• For example, if we have a field, name, that we want to initialize with a string whenever we create an object, we might write the following:

  public NamedThing(String _name)
  {
    this.name = _name;
  } // NamedThing(String)
  

• Many programmers make it a custom to give the parameter a name similar to the expected field, but prefixed by an underscore.
• Note that the fields you initialize need not be directly related to the parameters.
• For example, if we were to create a Counter class, we might want to initialize an integer counter field to 0 whenever an object in that class is created.

  int counter;
  public Counter()
  {
    this.counter = 0;
  } // Counter()
  

Three Kinds of Classes

• Although I haven't mentioned it explicitly, Java programmers use classes for a number of reasons. I typically classify them as mold classes, main classes, and utility classes.
• Mold classes provide molds 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.

• There are a number of methods that most mold 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 mold 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 mold class implements Comparable.
• compareTo returns one of three kinds of values
  • a negative number, if this object naturally preceeds the other object
  • zero, if this object is naturally the same as the other object
  • a positive number, if this object naturally follows the other object
• What should you do if the other object has no natural relationship? Give up.
  • We'll learn more about "giving up" tomorrow.

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.
• 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 use the hashCode method in the second half of the semester, but I'd like you to start using it now.