java.lang.Object

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

从以下版本开始：

1.0

另请参见：

Class

构造方法摘要

构造方法
Constructor	描述
`Object()`	构造一个新对象。

方法摘要

所有方法接口方法具体的方法弃用的方法
Modifier and Type	方法	描述
`protected Object`	`clone()`	创建并返回此对象的副本。
`boolean`	`equals(Object obj)`	指示一些其他对象是否等于此。
`protected void`	`finalize()`	已过时。定稿机制本质上是有问题的。定稿可能导致性能问题，死锁和挂起。敲定错误可能导致资源泄漏; 如果不再需要，无法取消定稿; 并且在不同对象的`finalize`方法的调用中没有指定排序。此外，关于定稿的时间并不保证。只有在无限期延迟之后，才能在可终止对象上调用`finalize`方法（如果有的话）。其实例持有非堆资源的类应提供一种方法来实现这些资源的显式释放，如果合适，它们还应实现`AutoCloseable` 。当对象变得不可达时， `Cleaner`和`PhantomReference`提供了更灵活和更有效的方式来释放资源。
`Class<?>`	`getClass()`	返回此 `Object`的运行时类。
`int`	`hashCode()`	返回对象的哈希码值。
`void`	`notify()`	唤醒正在等待对象监视器的单个线程。
`void`	`notifyAll()`	唤醒正在等待对象监视器的所有线程。
`String`	`toString()`	返回对象的字符串表示形式。
`void`	`wait()`	导致当前线程等待，直到另一个线程调用该对象的 `notify()`方法或 `notifyAll()`方法。
`void`	`wait(long timeout)`	导致当前线程等待，直到另一个线程调用该对象的 `notify()`方法或 `notifyAll()`方法，或指定的时间已过。
`void`	`wait(long timeout, int nanos)`	导致当前线程等待，直到另一个线程调用该对象的 `notify()`方法或 `notifyAll()`方法，或者某些其他线程中断当前线程，或者已经过了一定量的实时时间。

- 构造方法详细信息
  - Object
```
public Object()
```
    构造一个新对象。
- 方法详细信息
  - getClass
```
public final Class<?> getClass()
```
    返回此Object的运行时类。返回的Class对象是被表示类的static synchronized方法锁定的对象。
    实际的结果类型是Class<? extends |X|> ，其中|X|是被称为getClass的表达式的静态类型的擦除。 例如，在此代码片段中不需要转换：
    
    Number n = 0;
    Class<? extends Number> c = n.getClass();
    
    结果
    
    表示该对象的运行时类的 Class对象。
    
    See The Java™ Language Specification:
    
    15.8.2类文字
  - hashCode
```
public int hashCode()
```
    返回对象的哈希码值。支持这种方法有利于哈希表，如HashMap提供的那样。
    hashCode的总合同是：
    
    无论何时在执行Java应用程序时多次调用同一对象， hashCode方法必须始终返回相同的整数，前提是修改了对象中equals比较中的信息。该整数不需要从一个应用程序的执行到相同应用程序的另一个执行保持一致。
    
    如果根据equals(Object)方法两个对象相等，则在两个对象中的每个对象上调用hashCode方法必须产生相同的整数结果。
    
    不要求如果两个对象根据equals(java.lang.Object)方法不相等，则在两个对象中的每一个上调用hashCode方法必须产生不同的整数结果。但是，程序员应该意识到，为不等对象生成不同的整数结果可能会提高哈希表的性能。
    
    尽可能合理实用，由类Object定义的hashCode方法确实为不同对象返回不同的整数。（在某个时间点，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 。
    
    该equals类方法Object实现对象上差别可能性最大的相等关系; 也就是说，对于任何非空参考值x和y ，当且仅当x和y引用相同对象（ x == y具有值true ）时，该方法返回true 。
    
    请注意，无论何时覆盖此方法，通常需要覆盖hashCode方法，以便维护hashCode方法的一般合同，该方法规定相等的对象必须具有相等的哈希码。
    参数
    
    obj - 与之比较的参考对象。
    
    结果
    
    true如果此对象与obj参数相同; 否则为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返回的对象中的字段通常不需要修改。
    
    该方法clone类Object执行特定克隆操作。首先，如果此对象的类不实现接口Cloneable ，则抛出CloneNotSupportedException 。请注意，所有阵列被认为是实现该接口Cloneable并且所述的返回类型clone数组类型的方法T[]是T[]其中T是任何引用或原始类型。否则，该方法将创建该对象的类的新实例，并将其所有字段初始化为该对象的相应字段的内容，就像通过赋值一样。这些字段的内容本身不被克隆。因此，该方法执行该对象的“浅拷贝”，而不是“深度拷贝”操作。
    
    类Object本身并不实现接口Cloneable ，因此在类为Object的对象上调用clone方法将导致在运行时抛出异常。
    结果
    
    这个实例的一个克隆。
    
    异常
    
    CloneNotSupportedException - 如果对象的类不支持Cloneable接口。覆盖clone方法的子类也可以抛出此异常以指示实例无法克隆。
    
    另请参见：
    
    Cloneable
  - toString
```
public String toString()
```
    返回对象的字符串表示形式。一般来说， toString方法返回一个“ toString代表”这个对象的字符串。结果应该是一个简明扼要的表达，容易让人阅读。建议所有子类覆盖此方法。
    该toString类方法Object返回一个由类的名称，其中所述对象是其实例，该符号字符`的字符串@ ”，并且对象的哈希码的无符号的十六进制表示。换句话说，这个方法返回一个等于下列值的字符串：
    
    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(long timeout)
                throws InterruptedException
```
    导致当前线程等待，直到另一个线程调用此对象的notify()方法或notifyAll()方法，或指定的时间已过。
    当前的线程必须拥有该对象的显示器。
    
    此方法使当前线程（称为T ）将其放置在该对象的等待集中，然后放弃对该对象的任何和所有同步声明。线程T变得禁用线程调度目的，并且休眠，直到发生四件事情之一：
    
    一些其他线程调用该对象的notify方法，并且线程T恰好被任意选择为被唤醒的线程。
    
    一些其他线程调用此对象的notifyAll方法。
    
    一些其他线程interrupts线程T。
    
    指定的实时数量已经过去，或多或少。然而，如果timeout为零，则不考虑实时，并且线程等待直到通知。
    
    然后从该对象的等待集中删除线程T，并重新启用线程调度。然后它以通常的方式与其他线程竞争在对象上进行同步的权限; 一旦获得了对象的控制，对对象的所有同步声明就恢复到现状 - 也就是在调用wait方法时的情况。线程T然后从调用wait方法返回。因此，从wait方法返回时，对象和线程T的同步状态与调用wait方法时的状态wait 。
    线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒 。虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待。换句话说，等待应该总是出现在循环中，就像这样：
    
    synchronized (obj) { while (<condition does not hold>) obj.wait(timeout); ... // Perform action appropriate to condition }
    （有关此主题的更多信息，请参阅Brian Goetz中的第14.2节“条件队列”以及其他人在“Java并发实践”（Addison-Wesley，2006）或Joshua Bloch的“Effective Java（Second Edition）”（Addison -Wesley，2008）。
    如果当前线程在等待之前或之中任何线程是interrupted ，则抛出一个InterruptedException 。如上所述，在该对象的锁定状态已恢复之前，不会抛出此异常。
    
    请注意， wait方法，因为它将当前线程放置到此对象的等待集中，仅解锁此对象; 当前线程可以同步的任何其他对象在线程等待时保持锁定。
    
    该方法只能由作为该对象监视器的所有者的线程调用。有关线程可以成为监视器所有者的方法的说明，请参阅notify方法。
    参数
    
    timeout - 以毫秒为单位等待的最长时间。
    
    异常
    
    IllegalArgumentException - 如果超时值为负值。
    
    IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者。
    
    InterruptedException - 如果任何线程在当前线程等待通知之前或当前线程中断当前线程。当抛出此异常时，当前线程的中断状态将被清除。
    
    另请参见：
    
    notify() ， notifyAll()
  - wait
```
public final void wait(long timeout,
                       int nanos)
                throws InterruptedException
```
    导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法，或其他一些线程中断当前线程或一定量的实时时间。
    这种方法类似于一个参数的wait方法，但它允许对放弃之前等待通知的时间进行更精细的控制。以纳秒为单位的实时数量由下式给出：
    
    1000000*timeout+nanos
    
    在所有其他方面，该方法与一个参数的方法wait(long)相同。特别是wait(0, 0)意味着同样的事情wait(0) 。
    
    当前的线程必须拥有该对象的显示器。线程释放此监视器的所有权，并等待直到发生以下两种情况之一：
    
    另一个线程通知等待该对象监视器的线程通过调用notify方法或notifyAll方法notifyAll 。
    
    由timeout毫秒加上nanos纳秒参数指定的超时时间已过。
    
    然后线程等待，直到它可以重新获得监视器的所有权并恢复执行。
    
    像在一个参数版本中，中断和虚假唤醒是可能的，并且该方法应该始终在循环中使用：
    
    synchronized (obj) { while (<condition does not hold>) obj.wait(timeout, nanos); ... // Perform action appropriate to condition }
    该方法只能由作为该对象监视器的所有者的线程调用。有关线程可以成为监视器所有者的方式的描述，请参阅notify方法。
    参数
    
    timeout - 以毫秒为单位等待的最长时间。
    
    nanos - 额外的时间，以纳秒范围0-999999。
    
    异常
    
    IllegalArgumentException - 如果超时值为负值或 IllegalArgumentException值不在0-999999范围内。
    
    IllegalMonitorStateException - 如果当前线程不是此对象的监视器的所有者。
    
    InterruptedException - 如果任何线程在当前线程等待通知之前或当前线程中断当前线程。当抛出此异常时，当前线程的中断状态将被清除。
  - wait
```
public final void wait()
                throws InterruptedException
```
    导致当前线程等到另一个线程调用该对象的notify()方法或notifyAll()方法。换句话说，这个方法的行为就好像简单地执行调用wait(0) 。
    当前的线程必须拥有该对象的显示器。该线程释放此监视器的所有权，并等待直到另一个线程通知等待该对象的监视器的线程通过调用notify方法或notifyAll方法来唤醒。然后线程等待，直到它可以重新获得监视器的所有权并恢复执行。
    
    像在一个参数版本中，中断和虚假唤醒是可能的，并且该方法应该始终在循环中使用：
    
    synchronized (obj) { while (<condition does not hold>) obj.wait(); ... // Perform action appropriate to condition }
    该方法只能由作为该对象监视器的所有者的线程调用。有关线程可以成为监视器所有者的方式的说明，请参阅notify方法。
    异常
    
    IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者。
    
    InterruptedException - 如果任何线程在当前线程等待通知之前或当前线程中断当前线程。当抛出此异常时，当前线程的中断状态将被清除。
    
    另请参见：
    
    notify() ， notifyAll()
  - finalize
```
@Deprecated(since="9")
protected void finalize()
                 throws Throwable
```
    已过时。定稿机制本质上是有问题的。定稿可能导致性能问题，死锁和挂起。敲定错误可能导致资源泄漏; 如果不再需要，无法取消定稿; 并且在不同对象的finalize方法的调用中没有指定排序。此外，关于定稿的时间并不保证。只有在无限期延迟之后，才能在可终止对象上调用finalize方法（如果有的话）。其实例持有非堆资源的类应提供一种方法来实现这些资源的显式释放，如果适用，它们还应实现AutoCloseable 。 Cleaner和PhantomReference在对象变得不可达时提供更灵活和更有效的方式来释放资源。
    
    当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。一个子类覆盖finalize方法来处理系统资源或执行其他清理。
    finalize的一般合同是，如果Java¢虚拟机已经确定不再有任何方法可以由任何尚未死亡的线程访问该对象的方法被调用，除非是由于最后确定的其他对象或类的准备工作所采取的行动。 finalize方法可能会采取任何行动，包括使此对象再次可用于其他线程; 然而， finalize的通常目的是在对象不可撤销地丢弃之前执行清除操作。例如，表示输入/输出连接的对象的finalize方法可能会在对象被永久丢弃之前执行显式I / O事务来中断连接。
    
    finalize类的finalize方法Object执行特殊操作; 它只是返回正常。 Object子类可以覆盖此定义。
    
    Java编程语言不能保证哪个线程将为任何给定对象调用finalize方法。但是，确保调用finalize的线程在调用finalize时不会持有任何用户可见的同步锁。如果finalize方法抛出未捕获的异常，则会忽略该异常，并终止该对象的定类。
    
    在为对象调用了finalize方法之后，在Java虚拟机再次确定不再有任何方法可以使任何尚未死亡的线程访问此对象的任何方法之前，还将采取进一步措施，包括可能的操作由准备完成的其他对象或类别，此时可以丢弃对象。
    
    任何给定对象，Java虚拟机不会多次调用finalize方法。
    
    finalize方法引发的任何异常finalize导致该对象的终止被暂停，否则被忽略。
    API Note:
    
    嵌入非堆资源的类具有许多清除这些资源的选项。该类必须确保每个实例的生命周期比其嵌入的任何资源的寿命长。可以使用Reference.reachabilityFence(java.lang.Object)来确保对象保持可访问，同时嵌入在对象中的资源正在使用中。
    一个子类应该避免覆盖finalize方法，除非子类嵌入在收集实例之前必须清理的非堆资源。 Finalizer调用不会自动链接，与构造函数不同。如果一个子类覆盖了finalize那么它必须明确地调用超类终结器。为了防止异常提前终止终结链，子类应该使用一个try-finally块来确保总是调用super.finalize() 。例如，
    
    @Override protected void finalize() throws Throwable { try { ... // cleanup subclass state } finally { super.finalize(); } }
    
    异常
    
    Throwable - 这个方法提出的 异常
    
    另请参见：
    
    WeakReference ， PhantomReference
    
    See The Java™ Language Specification:
    
    12.6 Finalization of Class Instances

Class Object

构造方法摘要

方法摘要

构造方法详细信息

Object

方法详细信息

getClass

hashCode

equals

clone

toString

notify

notifyAll

wait

wait

wait

finalize