final Class<?> getClass( )
Obtains a Class object that describes the invoking
int hashCode( )
Returns the hash code associated with the invoking
final void notify( )
Resumes execution of a thread waiting on the
invoking object.
final void notifyAll( )
Resumes execution of all threads waiting on the
invoking object.
String toString( )
Returns a string that describes the object.
final void wait( )
Waits on another thread of execution.
throws InterruptedException
final void wait(long milliseconds)
Waits up to the specified number of milliseconds on
throws InterruptedException
another thread of execution.
final void wait(long milliseconds,
Waits up to the specified number of milliseconds
int nanoseconds)
plus nanoseconds on another thread of execution.
throws InterruptedException
TABLE 16-14
The Methods Defined by Object (continued)
Using clone( ) and the Cloneable Interface
Most of the methods defined by Object are discussed elsewhere in this topic. However, one
deserves special attention: clone( ). The clone( ) method generates a duplicate copy of the
object on which it is called. Only classes that implement the Cloneable interface can be cloned.
The Cloneable interface defines no members. It is used to indicate that a class allows a
bitwise copy of an object (that is, a clone) to be made. If you try to call clone( ) on a class that
does not implement Cloneable, a CloneNotSupportedException is thrown. When a clone
is made, the constructor for the object being cloned is not called. A clone is simply an exact
copy of the original.
Cloning is a potentially dangerous action, because it can cause unintended side effects.
For example, if the object being cloned contains a reference variable called obRef, then when
the clone is made, obRef in the clone will refer to the same object as does obRef in the original.
If the clone makes a change to the contents of the object referred to by obRef, then it will be
changed for the original object, too. Here is another example: If an object opens an I/O stream
and is then cloned, two objects will be capable of operating on the same stream. Further, if
one of these objects closes the stream, the other object might still attempt to write to it, causing
an error. In some cases, you will need to override the clone( ) method defined by Object to
handle these types of problems.
Because cloning can cause problems, clone( ) is declared as protected inside Object.
This means that it must either be called from within a method defined by the class that
implements Cloneable, or it must be explicitly overridden by that class so that it is public.
Let's look at an example of each approach.
Search WWH :
Custom Search
Previous Page
Java SE 6 Topic Index
Next Page
Java SE 6 Bookmarks