/*
* @(#)Object.java 1.39 97/01/20
*
* Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*
* CopyrightVersion 1.1_beta
*
*/
package java.lang;
/**
* Class Object is the root of the class hierarchy.
* Every class has Object as a superclass. All objects,
* including arrays, implement the methods of this class.
*
* @author unascribed
* @version 1.39, 01/20/97
* @see java.lang.Class
* @since JDK1.0
*/
public class Object {
/**
* Returns the runtime class of an object.
*
* @return the object of type Class that represents the
* runtime class of the object.
* @since JDK1.0
*/
public final native Class getClass();
/**
* Returns a hash code value for the object. This method is
* supported for the benefit of hashtables such as those provided by
* java.util.Hashtable.
*
* The general contract of hashCode is:
*
* Whenever it is invoked on the same object more than once during
* an execution of a Java application, the hashCode method
* must consistently return the same integer. This integer need not
* remain consistent from one execution of an application to another
* execution of the same application.
* If two objects are equal according to the equals
* method, then calling the hashCode method on each of the
* two objects must produce the same integer result.
*
*
* @return a hash code value for this object.
* @see java.lang.Object#equals(java.lang.Object)
* @see java.util.Hashtable
* @since JDK1.0
*/
public native int hashCode();
/**
* Compares two Objects for equality.
*
* The equals method implements an equivalence relation:
*
* It is reflexive: for any reference value x,
* x.equals(x) should return true.
* It is symmetric: for any reference values x and
* y, x.equals(y) should return
* true if and only if y.equals(x) returns
* true.
* It is transitive: for any reference values x,
* y, and z, if x.equals(y)
* returns true and y.equals(z) returns
* true, then x.equals(z) should return
* true.
* It is consistent: for any reference values x
* and y, multiple invocations of x.equals(y)
* consistently return true or consistently return
* false.
* For any reference value x, x.equals(null)
* should return false.
*
*
* The equals method for class Object implements the most
* discriminating possible equivalence relation on objects; that is,
* for any reference values x and y, this
* method returns true if and only if x and
* y refer to the same object (x==y has the
* value true).
*
* @param obj the reference object with which to compare.
* @return true if this object is the same as the obj
* argument; false otherwise.
* @see java.lang.Boolean#hashCode()
* @see java.util.Hashtable
* @since JDK1.0
*/
public boolean equals(Object obj) {
return (this == obj);
}
/**
* Creates a new object of the same class as this object. It then
* initializes each of the new object's fields by assigning it the
* same value as the corresponding field in this object. No
* constructor is called.
*
* The clone method of class Object will
* only clone an object whose class indicates that it is willing for
* its instances to be cloned. A class indicates that its instances
* can be cloned by declaring that it implements the
* Cloneable interface.
*
* @return a clone of this instance.
* @exception CloneNotSupportedException if the object's class does not
* support the Cloneable interface. Subclasses
* that override the clone method can also
* throw this exception to indicate that an instance cannot
* be cloned.
* @exception OutOfMemoryError if there is not enough memory.
* @see java.lang.Cloneable
* @since JDK1.0
*/
protected native Object clone() throws CloneNotSupportedException;
/**
* Returns a string representation of the object. In general, the
* toString method returns a string that
* "textually represents" this object. The result should
* be a concise but informative representation that is easy for a
* person to read.
* It is recommendedthat all subclasses override this method.
*
* The toString method for class Object
* returns a string consisting of the name of the class of which the
* object is an instance, the at-sign character `@', and
* the unsigned hexadecimal representation of the hash code of the
* object.
*
* @return a string representation of the object.
* @since JDK1.0
*/
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
/**
* Wakes up a single thread that is waiting on this object's
* monitor. A thread waits on an object's monitor by calling one of
* the wait methods.
*
* This method should only be called by a thread that is the owner
* of this object's monitor. A thread becomes the owner of the
* object's monitor in one of three ways:
*
* By executing a synchronized instance method of that object.
* By executing the body of a synchronized statement
* that synchronizes on the object.
* For objects of type Class, by executing a
* synchronized static method of that class.
*
*
* Only one thread at a time can own an object's monitor.
*
* @exception IllegalMonitorStateException if the current thread is not
* the owner of this object's monitor.
* @see java.lang.Object#notifyAll()
* @see java.lang.Object#wait()
* @since JDK1.0
*/
public final native void notify();
/**
* Wakes up all threads that are waiting on this object's monitor. A
* thread waits on an object's monitor by calling one of the
* wait methods.
*
* This method should only be called by a thread that is the owner
* of this object's monitor. See the notify method for a
* description of the ways in which a thread can become the owner of
* a monitor.
*
* @exception IllegalMonitorStateException if the current thread is not
* the owner of this object's monitor.
* @see java.lang.Object#notify()
* @see java.lang.Object#wait()
* @since JDK1.0
*/
public final native void notifyAll();
/**
* Waits to be notified by another thread of a change in this object.
*
* The current thread must own this object's monitor. The thread
* releases ownership of this monitor and waits until either of the
* following two conditions has occurred:
*
* Another thread notifies threads waiting on this object's monitor
* to wake up either through a call to the notify method
* or the notifyAll method.
* The timeout period, specified by the timeout
* argument in milliseconds, has elapsed.
*
*
* The thread then waits until it can re-obtain ownership of the
* monitor and resumes execution.
*
* This method should only be called by a thread that is the owner
* of this object's monitor. See the notify method for a
* description of the ways in which a thread can become the owner of
* a monitor.
*
* @param timeout the maximum time to wait in milliseconds.
* @exception IllegalArgumentException if the value of timeout is
* negative.
* @exception IllegalMonitorStateException if the current thread is not
* the owner of the object's monitor.
* @exception InterruptedException if another thread has
* interrupted this thread.
* @see java.lang.Object#notify()
* @see java.lang.Object#notifyAll()
* @since JDK1.0
*/
public final native void wait(long timeout) throws InterruptedException;
/**
* Waits to be notified by another thread of a change in this object.
*
* This method is similar to the wait method of one
* argument, but it allows finer control over the amount of time to
* wait for a notification before giving up.
*
* The current thread must own this object's monitor. The thread
* releases ownership of this monitor and waits until either of the
* following two conditions has occurred:
*
* Another thread notifies threads waiting on this object's monitor
* to wake up either through a call to the notify method
* or the notifyAll method.
* The timeout period, specified by timeout
* milliseconds plus nanos nanoseconds arguments, has
* elapsed.
*
*
* The thread then waits until it can re-obtain ownership of the
* monitor and resumes execution
*
* This method should only be called by a thread that is the owner
* of this object's monitor. See the notify method for a
* description of the ways in which a thread can become the owner of
* a monitor.
*
* @param timeout the maximum time to wait in milliseconds.
* @param nano additional time, in nanoseconds range
* 0-999999.
* @exception IllegalArgumentException if the value of timeout is
* negative or the value of nanos is
* not in the range 0-999999.
* @exception IllegalMonitorStateException if the current thread is not
* the owner of this object's monitor.
* @exception InterruptedException if another thread has
* interrupted this thread.
* @since JDK1.0
*/
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && timeout == 0)) {
timeout++;
}
wait(timeout);
}
/**
* Waits to be notified by another thread of a change in this object.
*
* The current thread must own this object's monitor. The thread
* releases ownership of this monitor and waits until another thread
* notifies threads waiting on this object's monitor to wake up
* either through a call to the notify method or the
* notifyAll method. The thread then waits until it can
* re-obtain ownership of the monitor and resumes execution.
*
* This method should only be called by a thread that is the owner
* of this object's monitor. See the notify method for a
* description of the ways in which a thread can become the owner of
* a monitor.
*
* @exception IllegalMonitorStateException if the current thread is not
* the owner of the object's monitor.
* @exception InterruptedException if another thread has
* interrupted this thread.
* @see java.lang.Object#notify()
* @see java.lang.Object#notifyAll()
* @since JDK1.0
*/
public final void wait() throws InterruptedException {
wait(0);
}
/**
* Called by the garbage collector on an object when garbage collection
* determines that there are no more references to the object.
* A subclass overrides the finalize method to dispose of
* system resources or to perform other cleanup.
*
* Any exception thrown by the finalize method causes
* the finalization of this object to be halted, but is otherwise
* ignored.
*
* The finalize method in Object does
* nothing.
*
* @exception java.lang.Throwable [Need description!]
* @since JDK1.0
*/
protected void finalize() throws Throwable { }
}
