More Features of the Java Language |
TheObject
class sits at the top of the class hierarchy tree in the Java platform. Every class in the Java system is a descendent, direct or indirect, of theObject
class. This class defines the basic state and behavior that all objects must have, such as the ability to compare oneself to another object, to convert to a string, to wait on a condition variable, to notify other objects that a condition variable has changed, and to return the class of the object.Your classes may want to override the following
Object
methods. Theequals
/hashCode
are listed together as they must be overridden together.Your class cannot override these
clone
equals
/hashCode
finalize
toString
Object
methods (they are final):
getClass
notify
notifyAll
wait
The
clone
MethodYou use theclone
method to create objects from other objects of the same type. By default, objects are not cloneable, soObject
's implementation of this method throws aCloneNotSupportedException
. If you want your class to be cloneable, you must implement theCloneable
interface and override this method.Your version of the
clone
method must provide for a field-by-field copy of the object being cloned. Here's a partial listing of a new version of theStack
class that implements theCloneable
interface and overrides theclone
method (changes are indicated with a change in font):The implementation forpublic class Stack implements Cloneable { private Vector items; // code for Stack's methods and constructor not shown protected Object Clone() { try { Stack s = (Stack)super.clone(); s.items = (Vector)items.clone(); return s; } catch (CloneNotSupportedException e) { // this shouldn't happen because Stack is Cloneable throw new InternalError(); } } }Stack
'sclone
method is relatively simple because it can callObject
's implementation of theclone
method. Also, the only member ofStack
, aVector
, is also cloneable. Be careful:clone
should not usenew
to create the clone and should not call constructors.The
equals
andhashCode
MethodsYou must override theequals
andhashCode
methods together.The
equals
method compares two objects for equality and returnstrue
if they are equal. Theequals
method provided in theObject
class uses the identity function to determine if objects are equal (if the objects compared are the exact same object the method returnstrue
).However, for some classes, two distinct objects of that type might be considered equal if they contain the same information. Consider this code that tests two
Integer
s,one
andanotherOne
, for equality:This program displaysInteger one = new Integer(1), anotherOne = new Integer(1); if (one.equals(anotherOne)) System.out.println("objects are equal");objects are equal
even thoughone
andanotherOne
reference two distinct objects. They are considered equal because the objects compared contain the same integer value.Your classes should only override the
equals
method if the identity function is not appropriate for your class. If you overrideequals
, then overridehashCode
as well.The value returned by
hashCode
is anint
that maps an object into a bucket in a hash table. An object must always produce the same hash code. However, objects can share hash codes (they aren't necessarily unique). Writing a "correct" hashing function is easy--always return the same hash code for the same object. Writing an "efficient" hashing function, one that provides a sufficient distribution of objects over the buckets, is difficult and is out of the scope of the tutorial.Even so, the hashing function for some classes is relatively obvious. For example, an obvious hash code for an
Integer
object is its integer value. For an example of a class that overrides theequals
andhashCode
methods, see theBingoBall
class in BINGO!.The
finalize
MethodTheObject
class provides a method,finalize
, that cleans up an object before it is garbage collected. This method's role during garbage collection was discussed previously in Cleaning Up Unused Objects. Also, Writing afinalize
Method showed you how to override thefinalize
method to handle the finalization needs for your classes.The
toString
MethodObject
'stoString
method returns aString
representation of the object. You can usetoString
along withSystem.out.println
to display a text representation of an object, such as the current thread:TheSystem.out.println(Thread.currentThread().toString());String
representation for an object depends entirely on the object. TheString
representation of anInteger
object is the integer value displayed as text. TheString
representation of aThread
object contains various attributes about the thread, such as its name and priority. For example, the previous line of code displays the following output:TheThread[main,5,main]toString
method is very useful for debugging. It behooves you to override this method in all your classes.The
getClass
MethodThegetClass
method is a final method that returns a runtime representation of the class of this object. This method returns aClass
object. You can query theClass
object for various information about the class, such as its name, its superclass, and the names of the interfaces that it implements. The following method gets and displays the class name of an object:One handy use of thevoid PrintClassName(Object obj) { System.out.println("The Object's class is " + obj.getClass().getName()); }getClass
method is to create a new instance of a class without knowing what the class is at compile time. The following sample method creates a new instance of the same class asobj
, which can be any class that inherits fromObject
(which means that it could be any class):Object createNewInstanceOf(Object obj) { return obj.getClass().newInstance(); }
Note: You also can get aClass
object from a class name using a class literal. For example, to get theClass
object for theString
class useString.class
. This is equivalent to, but more efficient than, callingClass.forName(String)
.
The
notify
,notifyAll
, andwait
MethodsYou cannot overrideObject
'snotify
andnotifyAll
methods and its three versions ofwait
. This is because they are critical for ensuring that threads are synchronized. The use of these methods is covered in Doing Two or More Tasks at Once: Threads. Take particular note of the section titled Synchronizing Threads.
More Features of the Java Language |