Java Reference
In-Depth Information
allowed if class Post had no toString method. However, the toString method in class
Object guarantees that this method is always available for any class.)
The output appears properly with all details, because each possible dynamic type
( MessagePost and PhotoPost ) overrides the toString method and the dynamic method
lookup ensures that the redefined method is executed.
The toString method is generally useful for debugging purposes. Often, it is very convenient
if objects can easily be printed out in a sensible format. Most of the Java library classes override
toString (all collections, for instance, can be printed out like this), and often it is a good idea
to override this method for our classes as well.
Object equality: equals and hashCode
It is often necessary to determine whether two objects are “the same.” The Object class defines
two methods, equals and hashCode , that have a close link with determining similarity. We
actually have to be careful when using phrases such as “the same”; this is because it can mean
two quite different things when talking about objects. Sometimes we wish to know whether two
different variables are referring to the same object. This is exactly what happens when an object
variable is passed as a parameter to a method: there is only one object, but both the original vari-
able and the parameter variable refer to it. The same thing happens when any object variable is as-
signed to another. These situations produce what is called reference equality. Reference equality is
tested for using the == operator. So the following test will return true if both var1 and var2 are
referring to the same object (or are both null ), and false if they are referring to anything else:
var1 == var2
Reference equality takes no account at all of the contents of the objects referred to, just whether
there is one object referred to by two different variables or two distinct objects. That is why we also
define content equality , as distinct from reference equality. A test for content equality asks whether
two objects are the same internally—that is, whether the internal states of two objects are the same.
This is why we rejected using reference equality for making string comparisons in Chapter 5.
What content equality between two particular objects means is something that is defined by the
objects' class. This is where we make use of the equals method that every class inherits from
the Object superclass. If we need to define what it means for two objects to be equal accord-
ing to their internal states, then we must override the equals method, which then allows us to
write tests such as
This is because the equals method inherited from the Object class actually makes a test for
reference equality. It looks something like this:
public boolean equals(Object obj)
return this == obj;
Because the Object class has no fields, there is no state to compare, and this method obviously
cannot anticipate fields that might be present in subclasses.
Search WWH ::

Custom Search