鸿蒙OS Object

Object

java.lang.Object

public class Object

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

构造函数摘要

方法总结

构造函数详细信息

Object

public Object()

方法详情

getClass

public final Class<?> getClass()

返回此 Object 的运行时类。 返回的 Class 对象是被表示类的静态同步方法锁定的对象。

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

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

返回：

表示此对象的运行时类的 Class 对象。

hashCode

public int hashCode()

返回对象的哈希码值。支持这种方法是为了有利于哈希表，例如 HashMap 提供的那些。

hashCode 的一般合约是：

• 每当在 Java 应用程序执行期间对同一对象多次调用时，hashCode 方法必须始终返回相同的整数，前提是没有修改对象上相等比较中使用的信息。该整数不需要从应用程序的一次执行到同一应用程序的另一次执行保持一致。
• 如果两个对象根据 equals(Object) 方法相等，则对两个对象中的每一个调用 hashCode 方法必须产生相同的整数结果。
• 如果根据 equals(java.lang.Object) 方法，如果两个对象不相等，则不要求对两个对象中的每一个调用 hashCode 方法必须产生不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。

在合理可行的情况下，由 Object 类定义的 hashCode 方法确实为不同的对象返回不同的整数。 （这通常通过将对象的内部地址转换为整数来实现，但 Java™ 编程语言不需要这种实现技术。）

返回：

此对象的哈希码值。

equals

public boolean equals(Object obj)

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

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

• 它是 reflexive：对于任何非空引用值 x，x.equals(x) 应该返回 true。
• 它是对称的：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应该返回 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。

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

请注意，每当重写该方法时，通常都需要重写 hashCode 方法，以维护 hashCode 方法的一般约定，即相等的对象必须具有相等的哈希码。

参数：

返回：

如果此对象与 obj 参数相同，则为 true； 否则为假。

clone

protected Object clone() throws CloneNotSupportedException

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

 x.clone() != x

将会为true，并且表达式：

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

将会为true，但这些不是绝对的要求。 虽然通常是这样的：

 x.clone().equals(x)

会是真的，这不是一个绝对的要求。

按照约定，返回的对象应该通过调用 super.clone 来获取。如果一个类及其所有超类（Object 除外）都遵守这个约定，那么 x.clone().getClass() == x.getClass() 就是这种情况。

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

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

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

返回：

此实例的克隆。

Throws:

toString

public String toString()

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

Object 类的 toString 方法返回一个字符串，该字符串由对象作为其实例的类的名称、at 符号字符“@”和对象哈希码的无符号十六进制表示形式组成。 换句话说，此方法返回一个等于以下值的字符串：

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

返回：

对象的字符串表示形式。

notify

public final void notify()

唤醒正在此对象的监视器上等待的单个线程。如果有任何线程正在等待该对象，则选择其中一个被唤醒。该选择是任意的，并由实施自行决定。线程通过调用其中一个等待方法在对象的监视器上等待。

在当前线程放弃对该对象的锁定之前，被唤醒的线程将无法继续。被唤醒的线程将以通常的方式与可能正在积极竞争以在此对象上同步的任何其他线程竞争；例如，被唤醒的线程在成为下一个锁定该对象的线程时不享有可靠的特权或劣势。

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

• 通过执行该对象的同步实例方法。
• 通过执行在对象上同步的同步语句的主体。
• 对于 Class 类型的对象，通过执行该类的同步静态方法。

一次只有一个线程可以拥有一个对象的监视器。

Throws:

notifyAll

public final void notifyAll()

唤醒正在此对象的监视器上等待的所有线程。 线程通过调用其中一个等待方法在对象的监视器上等待。

在当前线程放弃对该对象的锁定之前，被唤醒的线程将无法继续。 被唤醒的线程将以通常的方式与可能正在积极竞争以在该对象上同步的任何其他线程竞争； 例如，被唤醒的线程在成为下一个锁定该对象的线程时不享有可靠的特权或劣势。

此方法只能由作为该对象监视器所有者的线程调用。

Throws:

wait

public final void wait(long timeout) throws InterruptedException

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

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

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

• 某个其他线程调用了该对象的 notify 方法，而线程 T 恰好被任意选择为要被唤醒的线程。
• 其他一些线程为此对象调用 notifyAll 方法。
• 其他一些线程 Thread#interrupt() 线程 T。
• 或多或少已经过了指定的实时时间。但是，如果超时为零，则不考虑实时时间，线程只是等待直到收到通知。

然后将线程 T 从该对象的等待集中移除，并重新启用线程调度。然后它以通常的方式与其他线程竞争对象同步的权利；一旦它获得了对象的控制权，它对对象的所有同步声明都会恢复到之前的状态——即，恢复到调用等待方法时的状态。线程 T 然后从调用等待方法返回。因此，从等待方法返回时，对象和线程 T 的同步状态与调用等待方法时完全相同。

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

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

（有关此主题的更多信息，请参阅 Doug Lea 的“Java 中的并发编程（第二版）”（Addison-Wesley，2000）中的第 3.2.3 节，或 Joshua Bloch 的“有效的 Java 编程语言指南”（Addison- 韦斯利，2001）。

如果当前线程在等待之前或期间被任何线程中断，则抛出 InterruptedException。 在此对象的锁定状态已按上述恢复之前，不会引发此异常。

请注意，wait 方法将当前线程放入该对象的等待集中，仅解锁该对象； 当前线程可能同步的任何其他对象在线程等待时保持锁定。

此方法只能由作为该对象监视器所有者的线程调用。 有关线程可以成为监视器所有者的方式的描述，请参见 notify 方法。

参数：

Throws:

wait

public final void wait(long timeout, int nanos) throws InterruptedException

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

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

 1000000*timeout+nanos

在所有其他方面，此方法与一个参数的方法 wait(long) 执行相同的操作。 特别是，wait(0, 0) 与 wait(0) 的含义相同。

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

• 另一个线程通过调用 notify 方法或 notifyAll 方法通知在此对象的监视器上等待唤醒的线程。
• 超时时间（由 timeout 毫秒加上 nanos 纳秒参数指定）已经过去。

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

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

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

此方法只能由作为该对象监视器所有者的线程调用。

参数：

Throws:

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
     }

此方法只能由作为该对象监视器所有者的线程调用。

Throws:

finalize

protected void finalize() throws Throwable

当垃圾收集确定不再有对该对象的引用时，由对象上的垃圾收集器调用。子类覆盖 finalize 方法以释放系统资源或执行其他清理。

finalize 的一般约定是，当 Java™ 虚拟机确定不再有任何方法可以让任何尚未终止的线程访问此对象时调用它，除非是由于某个操作由准备完成的其他对象或类的完成所采取。 finalize 方法可以采取任何行动，包括使该对象再次可供其他线程使用；然而，finalize 的通常目的是在对象被不可撤销地丢弃之前执行清理操作。例如，代表输入/输出连接的对象的 finalize 方法可能会执行显式 I/O 事务以在对象被永久丢弃之前中断连接。

Object 类的 finalize 方法不执行任何特殊操作；它只是正常返回。 Object 的子类可以覆盖这个定义。

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

在为一个对象调用 finalize 方法之后，不会采取进一步的行动，直到 Java 虚拟机再次确定没有任何方法可以让任何尚未终止的线程访问该对象，包括可能的行动由其他准备完成的对象或类，此时该对象可能被丢弃。

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

finalize 方法抛出的任何异常都会导致该对象的终结被暂停，否则会被忽略。

Throws: