Object

Object

Object ()

equals

boolean equals (Object obj)

指示其他某个对象是否“等于”这一个。

equals方法在非空对象引用上实现等价关系：

• It is reflexive: for any non-null reference value x, x.equals(x) should return true.
• It is symmetric: for any non-null 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 non-null 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 non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
• For any non-null reference value x, x.equals(null) should return false.

类Object的equals方法实现了对象上最可能的等价关系; 也就是说，对于任何非空引用值x和y ，此方法返回true当且仅当x和y引用同一对象（ x == y的值为true ）。

请注意，无论何时重写此方法，通常都需要重写 hashCode方法，以便维护 hashCode方法的一般合同，该方法声明等同对象必须具有相同的哈希代码。

Parameters
obj	Object: the reference object with which to compare.

Returns
boolean	true if this object is the same as the obj argument; false otherwise.

getClass

Class<?> getClass ()

返回此Object的运行时类。 返回的Class对象是被表示类的static synchronized方法锁定的对象。

实际结果类型为Class<? extends |X|>其中|X|是静态类型上其表达的擦除getClass被调用。 例如，在此代码片段中不需要强制转换：

Number n = 0;
Class<? extends Number> c = n.getClass();

Returns
Class<?>	The Class object that represents the runtime class of this object.

hashCode

int hashCode ()

返回对象的哈希码值。 为了散列表的好处而支持此方法，例如由HashMap提供的HashMap 。

hashCode的总合同是：

• 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, provided no information used in equals comparisons on the object is modified. 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(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
• It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.

尽可能合理实用，类Object定义的hashCode方法确实为不同的对象返回不同的整数。 （这通常通过将对象的内部地址转换为整数来实现，但Java ^TM编程语言不需要此实现技术。）

Returns
int	a hash code value for this object.

notify

void notify ()

唤醒正在等待该对象监视器的单个线程。 如果任何线程正在等待这个对象，则选择其中一个线程来唤醒。 这种选择是任意的，并且由实施决定。 线程通过调用wait方法之一等待对象的监视器。

被唤醒的线程将无法继续，直到当前线程放弃对该对象的锁定。 被唤醒的线程将以通常的方式与任何其他可能主动竞争同一个对象的线程竞争; 例如，被唤醒的线程在作为下一个线程来锁定这个对象时没有可靠的特权或缺点。

此方法只应由作为此对象监视器所有者的线程调用。 线程以三种方式之一成为对象监视器的所有者：

• 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.

一次只有一个线程可以拥有对象的显示器。

Throws
IllegalMonitorStateException	if the current thread is not the owner of this object's monitor.

notifyAll

void notifyAll ()

唤醒在该对象监视器上等待的所有线程。 线程通过调用wait方法之一等待对象的监视器。

被唤醒的线程将无法继续，直到当前线程放弃对该对象的锁定。 被唤醒的线程将以通常的方式与其他可能正在主动竞争的线程竞争以在该对象上同步; 例如，被唤醒的线程在作为下一个线程来锁定这个对象时没有可靠的特权或缺点。

此方法只应由作为此对象监视器所有者的线程调用。 有关线程可以成为监视器所有者的方式的说明，请参阅notify方法。

Throws
IllegalMonitorStateException	if the current thread is not the owner of this object's monitor.

toString

String toString ()

返回对象的字符串表示形式。 通常， toString方法将返回一个“文本地表示”该对象的字符串。 结果应该是一个简洁但内容丰富的表述，对于一个人来说很容易阅读。 建议所有子类重写此方法。

类Object的toString方法返回一个字符串，其中包含对象为实例的类的名称，符号字符“ @ ”以及对象的哈希代码的无符号十六进制表示形式。 换句话说，这个方法返回一个字符串，其值等于：

 getClass().getName() + '@' + Integer.toHexString(hashCode())
 

Returns
String	a string representation of the object.

wait

void wait (long millis, 
                int nanos)

导致当前线程等待，直到另一个线程为该对象调用 notify()方法或 notifyAll()方法，或者某个其他线程中断当前线程，或者经过一定的实时时间。

此方法类似于一个参数的wait方法，但它允许更好地控制在放弃之前等待通知的时间量。 以纳秒为单位测量的实时量由下式给出：

 1000000*timeout+nanos

在所有其他方面，这个方法和一个参数的方法wait(long) 。 特别是wait(0, 0)意味着同样的事情wait(0) 。

当前线程必须拥有该对象的监视器。 该线程释放此监视器的所有权并等待，直到发生以下两种情况之一：

• 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.

该线程然后等待，直到它可以重新获得监视器的所有权并恢复执行。

与在一个参数版本中一样，中断和虚假唤醒也是可能的，并且此方法应始终用于循环：

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout, nanos);
         ... // Perform action appropriate to condition
     }
 

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.

Parameters
millis	long: the maximum time to wait in milliseconds.
nanos	int: additional time, in nanoseconds range 0-999999.

Throws
IllegalArgumentException	if the value of timeout is negative or the value of nanos is not in the range 0-999999.
IllegalMonitorStateException	if the current thread is not the owner of this object's monitor.
InterruptedException	if any thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.

wait

void wait (long millis)

导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法或经过指定的时间量。

当前线程必须拥有该对象的监视器。

此方法使当前线程（称为T ）将自己置于此对象的等待集中，然后放弃此对象上的任何和所有同步声明。 为了线程调度目的，线程T被禁用，并且处于休眠状态，直到发生以下四种情况之一：

• Some other thread invokes the notify method for this object and thread T happens to be arbitrarily chosen as the thread to be awakened.
• Some other thread invokes the notifyAll method for this object.
• Some other thread interrupts thread T.
• The specified amount of real time has elapsed, more or less. If timeout is zero, however, then real time is not taken into consideration and the thread simply waits until notified.

The thread T is then removed from the wait set for this object and re-enabled for thread scheduling. It then competes in the usual manner with other threads for the right to synchronize on the object; once it has gained control of the object, all its synchronization claims on the object are restored to the status quo ante - that is, to the situation as of the time that the wait method was invoked. Thread T then returns from the invocation of the wait method. Thus, on return from the wait method, the synchronization state of the object and of thread T is exactly as it was when the wait method was invoked.

线程也可以在不通知，中断或超时的情况下唤醒 ，即所谓的虚假唤醒 。 虽然这在实践中很少会发生，但应用程序必须通过测试应该引起线程被唤醒的条件来防范它，并且在条件不满足时继续等待。 换句话说，等待应该总是发生在循环中，就像这样：

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }
 

(For more information on this topic, see Section 3.2.3 in Doug Lea's "Concurrent Programming in Java (Second Edition)" (Addison-Wesley, 2000), or Item 50 in Joshua Bloch's "Effective Java Programming Language Guide" (Addison-Wesley, 2001).

如果任何线程在当前线程interrupted之前或等待期间，则引发InterruptedException 。 直到此对象的锁定状态已按上述方式恢复之后，才会抛出此异常。

请注意， wait方法，因为它将当前线程置于此对象的等待集中，仅解锁此对象; 线程等待时，当前线程可能同步的任何其他对象将保持锁定状态。

此方法只应由作为此对象监视器所有者的线程调用。 有关线程可以成为监视器所有者的方式的说明，请参阅notify方法。

Parameters
millis	long: the maximum time to wait in milliseconds.

Throws
IllegalArgumentException	if the value of timeout is negative.
IllegalMonitorStateException	if the current thread is not the owner of the object's monitor.
InterruptedException	if any thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.

wait

void wait ()

导致当前线程等待，直到另一个线程调用此对象的notify()方法或notifyAll()方法。 换句话说，这个方法的行为就好像它只是执行调用wait(0) 。

当前线程必须拥有该对象的监视器。 该线程释放此监视器的所有权，并等待另一个线程通知调用notify方法或notifyAll方法时，等待该对象监视器的线程通知其唤醒。 该线程然后等待，直到它可以重新获得监视器的所有权并恢复执行。

与在一个参数版本中一样，中断和虚假唤醒也是可能的，并且此方法应始终用于循环：

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait();
         ... // Perform action appropriate to condition
     }
 

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.

Throws
IllegalMonitorStateException	if the current thread is not the owner of the object's monitor.
InterruptedException	if any thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.

clone

Object clone ()

创建并返回此对象的副本。 “复制”的确切含义可能取决于对象的类别。 一般意图是，对于任何对象x ，表达式：

 x.clone() != x

will be true, and that the expression:

 x.clone().getClass() == x.getClass()

will be true, but these are not absolute requirements. While it is typically the case that:

 x.clone().equals(x)

will be true, this is not an absolute requirement.

按照惯例，返回的对象应该通过调用super.clone获得。 如果一个类和它的所有超类（除了Object ）都遵守这个约定，那将是这样的情况，即x.clone().getClass() == x.getClass() 。

按照惯例，这个方法返回的对象应该独立于这个对象（被克隆）。 为了实现这种独立性，可能需要在返回super.clone之前修改对象的一个或多个字段。 通常，这意味着复制包含被克隆对象的内部“深层结构”的任何可变对象，并将这些对象的引用替换为对这些副本的引用。 如果一个类只包含原始字段或对不可变对象的引用，那么通常情况下不需要修改super.clone返回的对象中的字段。

类Object的方法clone执行特定的克隆操作。 首先，如果此对象的类未实现接口Cloneable ，则会引发CloneNotSupportedException 。 请注意，所有数组都被视为实现接口Cloneable并且数组类型T[]的clone方法的返回类型为T[] ，其中T是任何引用或基本类型。 否则，此方法创建该对象的类的新实例，并使用该对象的相应字段的内容来初始化其所有字段，就像通过赋值一样; 这些字段的内容本身并不克隆。 因此，此方法执行此对象的“浅拷贝”，而不是“深拷贝”操作。

类 Object本身并不实现接口 Cloneable ，所以在类 Object的对象上调用 clone方法将导致在运行时抛出异常。

Returns
Object	a clone of this instance.

Throws
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.

finalize

void finalize ()

当垃圾收集确定没有更多对该对象的引用时，由对象上的垃圾回收器调用。 子类会覆盖finalize方法以处置系统资源或执行其他清理。

的常规协定finalize是，它被调用，如果当在Java ^TM虚拟机已确定不再有由该目的可以通过还没有死亡，除了作为一个动作的结果的任何线程访问的任何手段取决于某些其他可以完成的对象或类别的最终定稿。 finalize方法可以采取任何行动，包括使该对象再次可用于其他线程; 但是， finalize的通常目的是在对象被不可撤销地丢弃之前执行清理操作。 例如，表示输入/输出连接的对象的finalize方法可能会执行显式I / O事务，以在永久丢弃该对象之前中断连接。

类Object的finalize方法Object执行特殊操作; 它只是正常返回。 Object子类可能会覆盖此定义。

Java编程语言不保证哪个线程将为任何给定的对象调用finalize方法。 但是，保证调用finalize的线程在调用finalize时不会保留任何用户可见的同步锁。 如果finalize方法引发未捕获的异常，则忽略该异常，并终止该对象的终止。

在针对某个对象调用了 finalize方法之后，在Java虚拟机再次确定不再有任何方法可以通过尚未死亡的任何线程访问此对象，包括可能的操作通过准备完成的其他对象或类别，此时该对象可能被丢弃。

对于任何给定对象，Java虚拟机永远不会多次调用 finalize方法。

finalize方法引发的任何异常 finalize导致终止此对象的终止，但会被忽略。

Throws
Throwable	the 异常 raised by this method