java.lang.Object

public class Object

类 Object 是类层次结构的根。每个类都将 Object 作为超类。所有对象，包括数组，都实现了这个类的方法。

自版本:

1.0

另请参见:

Constructor Summary

Constructors

Constructor

Description

Object()

构造一个新对象。
Method Summary

Modifier and Type

Method

Description

protected Object

clone()

创建并返回此对象的副本。

boolean

equals(Object obj)

指示某个其他对象是否与此对象“相等”。

protected void

finalize()

已弃用，将来会移除：此 API 元素可能会在将来的版本中移除。
终结已被弃用，并可能在将来的版本中移除。

final Class<?>

getClass()

返回此 Object 的运行时类。

int

hashCode()

返回对象的哈希码值。

final void

notify()

唤醒正在等待此对象监视器的单个线程。

final void

notifyAll()

唤醒正在等待此对象监视器的所有线程。

String

toString()

返回对象的字符串表示形式。

final void

wait()

使当前线程等待，直到被“通知”或“中断”为止。

final void

wait(long timeoutMillis)

使当前线程等待，直到被“通知”或“中断”为止，或者直到经过一定的实际时间。

final void

wait(long timeoutMillis, int nanos)

使当前线程等待，直到被“通知”或“中断”为止，或者直到经过一定的实际时间。

Constructor Details
- Object
  
  public Object()
  
  构造一个新对象。
Method Details
- getClass
  
  public final Class<?> getClass()
  
  返回此 Object 的运行时类。返回的 Class 对象是由所代表类的 static synchronized 方法锁定的对象。
  实际结果类型为 Class<? extends |X|>，其中 |X| 是调用 getClass 的表达式的静态类型的擦除。例如，在此代码片段中不需要进行转换：
  
  Number n = 0;
  Class<? extends Number> c = n.getClass();
  
  返回:
  
  表示此对象的运行时类的 Class 对象。
  
  参见 Java 语言规范:
  
  15.8.2 类文字
- hashCode
  
  public int hashCode()
  返回对象的哈希码值。此方法支持哈希表（如 HashMap）等的好处。
  hashCode 的一般约定是：
  
  在 Java 应用程序的执行过程中，如果对同一对象多次调用 hashCode 方法，则只要对象上用于 equals 比较的信息未被修改，hashCode 方法必须始终一致地返回相同的整数。这个整数不需要在应用程序的一个执行到另一个执行之间保持一致。
  
  如果两个对象根据 equals 方法是相等的，则在这两个对象的每个对象上调用 hashCode 方法必须产生相同的整数结果。
  
  如果根据 equals 方法两个对象是不相等的，则不需要保证在这两个对象的每个对象上调用 hashCode 方法会产生不同的整数结果。但是，程序员应该意识到，对于不相等的对象产生不同的整数结果可能会提高哈希表的性能。
  实现要求:
  
  尽可能地，由类 Object 定义的 hashCode 方法为不同的对象返回不同的整数。
  
  返回:
  
  此对象的哈希码值。
  
  另请参见:
  
  equals(java.lang.Object)
  
  System.identityHashCode(java.lang.Object)
- equals
  
  public boolean equals(Object obj)
  指示某个其他对象是否与此对象“相等”。
  equals 方法在非空对象引用上实现了等价关系：
  
  它是自反的：对于任何非空引用值 x，x.equals(x) 应该返回 true。
  
  它是对称的：对于任何非空引用值 x 和 y，如果且仅如果 x.equals(y) 返回 true，则 y.equals(x) 应该返回 true。
  
  它是传递的：对于任何非空引用值 x，y 和 z，如果 x.equals(y) 返回 true 并且 y.equals(z) 返回 true，则 x.equals(z) 应该返回 true。
  
  它是一致的：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 应该一致地返回 true 或一致地返回 false，前提是在对象上用于 equals 比较的信息未被修改。
  
  对于任何非空引用值 x，x.equals(null) 应该返回 false。
  
  等价类；等价类的所有成员彼此相等。等价类的成员可以互换使用，至少对于某些目的而言是这样的。
  API 注释:
  
  通常需要在重写此方法时重写 hashCode 方法，以保持 hashCode 方法的一般约定，即相等的对象必须具有相等的哈希码。
  
  实现要求:
  
  类 Object 的 equals 方法实现了对象上最具有区别力的等价关系；也就是说，对于任何非空引用值 x 和 y，只有当 x 和 y 引用同一个对象（x == y 的值为 true）时，此方法才返回 true。换句话说，在引用相等等价关系下，每个等价类只有一个元素。
  
  参数:
  
  obj - 用于比较的引用对象。
  
  返回:
  
  如果此对象与 obj 参数相同，则返回 true；否则返回 false。
  
  另请参见:
  
  hashCode()
  
  HashMap
- clone
  
  protected Object clone() throws CloneNotSupportedException
  创建并返回此对象的副本。 “副本”的确切含义可能取决于对象的类。一般意图是，对于任何对象 x，表达式：
  
  x.clone() != x
  
  将为真，并且表达式：
  
  x.clone().getClass() == x.getClass()
  
  将为 true，但这些不是绝对要求。虽然通常情况下：
  
  x.clone().equals(x)
  
  将为 true，但这不是绝对要求。 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 方法将导致在运行时抛出异常。
  
  返回:
  
  此实例的克隆。
  
  抛出:
  
  CloneNotSupportedException - 如果对象的类不支持 Cloneable 接口。重写 clone 方法的子类也可以抛出此异常，以指示无法克隆实例。
  
  另请参见:
  
  Cloneable
- toString
  
  public String toString()
  
  返回对象的字符串表示形式。
  API注释:
  
  通常情况下，toString方法返回一个字符串，该字符串“文本表示”此对象。结果应该是简洁但信息丰富的表示，易于人们阅读。建议所有子类都重写此方法。字符串输出不一定随时间稳定或在JVM调用之间稳定。
  
  实现要求:
  
  对于类Object，toString方法返回一个字符串，该字符串由对象是其实例的类的名称、at符号`@'和对象的哈希码的无符号十六进制表示组成。换句话说，此方法返回一个等于以下值的字符串:
  
  getClass().getName() + '@' + Integer.toHexString(hashCode())
  
  返回:
  
  对象的字符串表示形式。
- notify
  
  public final void notify()
  唤醒等待在此对象监视器上的单个线程。如果有任何线程在此对象上等待，则会选择其中一个来唤醒。选择是任意的，并由实现自行决定。线程通过调用wait方法在对象的监视器上等待。
  唤醒的线程在当前线程放弃对此对象的锁定之前将无法继续。唤醒的线程将以通常的方式与可能正在积极竞争以在此对象上同步的任何其他线程竞争；例如，唤醒的线程在成为下一个锁定此对象的线程方面没有可靠的特权或劣势。
  
  此方法只能由拥有此对象监视器的线程调用。线程以以下三种方式之一成为对象监视器的所有者：
  
  通过执行该对象的同步实例方法。
  
  通过执行同步在该对象上同步的synchronized语句的主体。
  
  对于Class类型的对象，通过执行该类的静态同步方法。
  
  一次只能有一个线程拥有对象的监视器。
  抛出:
  
  IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
  
  参见:
  
  notifyAll()
  
  wait()
- notifyAll
  
  public final void notifyAll()
  
  唤醒等待在此对象监视器上的所有线程。线程通过调用wait方法在对象的监视器上等待。
  唤醒的线程在当前线程放弃对此对象的锁定之前将无法继续。唤醒的线程将以通常的方式与可能正在积极竞争以在此对象上同步的任何其他线程竞争；例如，唤醒的线程在成为下一个锁定此对象的线程方面没有可靠的特权或劣势。
  
  此方法只能由拥有此对象监视器的线程调用。有关线程如何成为监视器所有者的描述，请参阅notify方法。
  抛出:
  
  IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
  
  参见:
  
  notify()
  
  wait()
- wait
  
  public final void wait() throws InterruptedException
  
  使当前线程等待，直到被唤醒，通常是通过通知或中断。
  在所有方面，此方法的行为就像调用了wait(0L, 0)一样。有关详细信息，请参阅wait(long, int)方法的规范。
  抛出:
  
  IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者
  
  InterruptedException - 如果在当前线程等待之前或期间，任何线程中断了当前线程。抛出此异常时，当前线程的中断状态将被清除。
  
  参见:
  
  notify()
  
  notifyAll()
  
  wait(long)
  
  wait(long, int)
- wait
  
  public final void wait(long timeoutMillis) throws InterruptedException
  
  使当前线程等待，直到被唤醒，通常是通过通知或中断，或者直到经过一定的实际时间。
  在所有方面，此方法的行为就像调用了wait(timeoutMillis, 0)一样。有关详细信息，请参阅wait(long, int)方法的规范。
  参数:
  
  timeoutMillis - 等待的最长时间，以毫秒为单位
  
  抛出:
  
  IllegalArgumentException - 如果timeoutMillis为负数
  
  IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者
  
  InterruptedException - 如果在当前线程等待之前或期间，任何线程中断了当前线程。抛出此异常时，当前线程的中断状态将被清除。
  
  参见:
  
  notify()
  
  notifyAll()
  
  wait()
  
  wait(long, int)
- wait
  
  public final void wait(long timeoutMillis, int nanos) throws InterruptedException
  使当前线程等待，直到被唤醒，通常是通过通知或中断，或者直到经过一定的实际时间。
  当前线程必须拥有此对象的监视器锁。请参阅notify方法，了解线程如何成为监视器锁的所有者的描述。
  
  此方法导致当前线程（在此处称为T）将自己放置在此对象的等待集中，然后放弃对此对象的所有同步声明。请注意，只有此对象上的锁定将被放弃；当前线程可能同步的任何其他对象在线程等待时仍然被锁定。
  
  然后，线程T因线程调度目的而被禁用，并处于休眠状态，直到发生以下情况之一：
  
  其他某个线程为此对象调用notify方法，并且线程T恰好被选择为要唤醒的线程。
  
  其他某个线程为此对象调用notifyAll方法。
  
  其他某个线程中断了线程T。
  
  经过了指定的实际时间，多或少。实际时间的纳秒数由表达式1000000 * timeoutMillis + nanos给出。如果timeoutMillis和nanos都为零，则不考虑实际时间，线程将等待直到被其他原因唤醒。
  
  线程T被虚假唤醒。（见下文。）
  
  然后，线程T从此对象的等待集中移除，并重新启用以进行线程调度。它将以通常的方式与其他线程竞争以获得对对象的同步权利；一旦它重新获得对对象的控制，所有其对对象的同步声明将恢复到先前的状态 - 也就是说，与调用wait方法时的情况相同。然后，线程T从wait方法的调用返回。因此，从wait方法返回时，对象的同步状态和线程T的同步状态与调用wait方法时完全相同。
  
  线程可以在没有被通知、中断或超时的情况下唤醒，这称为虚假唤醒。虽然这在实践中很少发生，但应用程序必须通过测试应该导致线程被唤醒的条件，并在条件不满足时继续等待来防范。请参阅下面的示例。
  
  有关此主题的更多信息，请参阅Brian Goetz等人的《Java并发实践》（Addison-Wesley，2006）第14.2节“条件队列”或Joshua Bloch的《Effective Java，第三版》（Addison-Wesley，2018）第81项。
  
  如果当前线程在等待时被任何线程中断，则会抛出InterruptedException。抛出此异常时，当前线程的中断状态将被清除。此异常直到此对象的锁定状态已恢复为上述描述的状态才会抛出。
  API注释:
  
  等待的推荐方法是在调用wait时，使用while循环检查正在等待的条件，如下例所示。这种方法避免了由虚假唤醒引起的问题，等待超时后继续执行适合条件或超时的操作。
  synchronized (obj) { while (<条件不成立> 并且 <超时未达到>) { long timeoutMillis = ... ; // 重新计算超时值 int nanos = ... ; obj.wait(timeoutMillis, nanos); } ... // 执行适合条件或超时的操作 }
  
  参数:
  
  timeoutMillis - 最大等待时间，以毫秒为单位
  
  nanos - 附加时间，以纳秒为单位，范围在0-999999之间
  
  抛出:
  
  IllegalArgumentException - 如果timeoutMillis为负数，或者nanos的值超出范围
  
  IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者
  
  InterruptedException - 如果在当前线程等待之前或期间，任何线程中断了当前线程。抛出此异常时，当前线程的中断状态将被清除。
  
  参见:
  
  notify()
  
  notifyAll()
  
  wait()
  
  wait(long)
- finalize
  
  @Deprecated(since="9", forRemoval=true) protected void finalize() throws Throwable
  
  Deprecated, for removal: This API element is subject to removal in a future version.
  Finalization is deprecated and subject to removal in a future release. The use of finalization can lead to problems with security, performance, and reliability. See JEP 421 for discussion and alternatives.
  Subclasses that override finalize to perform cleanup should use alternative cleanup mechanisms and remove the finalize method. Use Cleaner and PhantomReference as safer ways to release resources when an object becomes unreachable. Alternatively, add a close method to explicitly release resources, and implement AutoCloseable to enable use of the try-with-resources statement.
  
  This method will remain in place until finalizers have been removed from most existing code.
  
  垃圾收集器在确定对象没有更多引用时，会调用对象上的finalize方法。子类可以重写finalize方法来处理系统资源的释放或执行其他清理操作。
  在禁用或移除了终结操作的Java虚拟机中运行时，垃圾收集器永远不会调用finalize()。在启用终结操作的Java虚拟机中，垃圾收集器可能会在不确定的延迟后才调用finalize。
  
  finalize的一般约定是，当Java虚拟机确定没有任何线程可以访问该对象（除了由其他对象或类的终结操作采取的操作外）时，将调用它。finalize方法可以执行任何操作，包括再次使该对象可供其他线程使用；然而，finalize的通常目的是在对象被彻底丢弃之前执行清理操作。例如，表示输入/输出连接的对象的终结方法可能执行显式的I/O事务以断开连接，然后才永久丢弃对象。
  
  Object类的finalize方法不执行任何特殊操作；Object的子类可以重写此定义。
  
  Java编程语言不保证哪个线程会为任何给定对象调用finalize方法。但是，保证调用finalize的线程在调用finalize时不会持有任何用户可见的同步锁。如果finalize方法抛出未捕获的异常，则异常将被忽略，并且该对象的终结将终止。
  
  在为对象调用finalize方法后，直到Java虚拟机再次确定没有任何线程可以访问该对象（包括其他对象或类可能采取的终结操作），才会采取进一步操作，此时对象可能会被丢弃。
  
  Java虚拟机永远不会为任何给定对象多次调用finalize方法。
  
  finalize方法抛出的任何异常都会导致该对象的终结被停止，但否则会被忽略。
  API注释:
  
  包含非堆资源的类有许多清理这些资源的选项。该类必须确保每个实例的生命周期长于任何嵌入的资源。可以使用Reference.reachabilityFence(java.lang.Object)来确保对象在嵌入在对象中的资源正在使用时仍然可访问。
  子类应避免重写finalize方法，除非子类嵌入了必须在实例被收集之前清理的非堆资源。终结器调用不会自动链接，不像构造函数。如果子类重写finalize，则必须显式调用超类终结器。为防止异常过早终止终结链，子类应使用try-finally块确保始终调用super.finalize()。例如，
  
  @Override protected void finalize() throws Throwable { try { ... // 清理子类状态 } finally { super.finalize(); } }
  
  抛出:
  
  Throwable - 该方法引发的Exception
  
  参见Java语言规范:
  
  12.6 类实例的终结
  
  参见:
  
  WeakReference
  
  PhantomReference

Class Object

Constructor Summary

Method Summary

Constructor Details

Object

Method Details

getClass

hashCode

equals

clone

toString

notify

notifyAll

wait

wait

wait

finalize