模块 java.base
 java.lang

类 Object

java.lang.Object

public class Object
Object 是类层次结构的根。每个类都有 Object 作为超类。所有对象,包括数组,都实现了这个类的方法。
自从:
1.0
参见:
  • 构造方法总结

    构造方法
    构造方法
    描述
    构造一个新对象。
  • 方法总结

    修饰符和类型
    方法
    描述
    protected Object
    创建并返回此对象的副本。
    boolean
    equals(Object obj)
    指示某个其他对象是否“等于”这个对象。
    protected void
    已弃用,将被删除:此 API 元素可能会在未来版本中删除。
    Finalization 已弃用,并可能在未来的版本中删除。
    final Class<?>
    返回此 Object 的运行时类。
    int
    返回对象的哈希码值。
    final void
    唤醒在此对象的监视器上等待的单个线程。
    final void
    唤醒在此对象的监视器上等待的所有线程。
    返回对象的字符串表示形式。
    final void
    wait()
    导致当前线程等待直到被唤醒,通常是 notifiedinterrupted
    final void
    wait(long timeoutMillis)
    导致当前线程等待直到它被唤醒,通常是被 notifiedinterrupted 唤醒,或者直到经过一定的实时时间。
    final void
    wait(long timeoutMillis, int nanos)
    导致当前线程等待直到它被唤醒,通常是被 notifiedinterrupted 唤醒,或者直到经过一定的实时时间。
  • 构造方法详细信息

    • 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 对象。
      Java 语言规范:
      15.8.2 类文字
    • hashCode

      public int hashCode()
      返回对象的哈希码值。支持此方法是为了哈希表的好处,例如 HashMap 提供的哈希表。

      hashCode的总合同为:

      • 每当在 Java 应用程序的执行期间对同一个对象多次调用时,hashCode 方法必须始终返回相同的整数,前提是在对象的equals 比较中使用的信息没有被修改。从一个应用程序的一次执行到同一应用程序的另一次执行,该整数不需要保持一致。
      • 如果根据 equals 方法两个对象相等,则对这两个对象中的每一个调用 hashCode 方法必须产生相同的整数结果。
      • not 要求如果根据 equals 方法两个对象不相等,则对这两个对象中的每一个调用 hashCode 方法必须产生不同的整数结果。但是,程序员应该意识到,为不相等的对象生成不同的整数结果可能会提高哈希表的性能。
      实现要求:
      就合理实用而言,类 Object 定义的 hashCode 方法为不同的对象返回不同的整数。
      返回:
      此对象的哈希码值。
      参见:
    • equals

      public boolean equals(Object  obj)
      指示某个其他对象是否“等于”这个对象。

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

      • 这是反身的:对于任何非空参考值 xx.equals(x) 应该返回 true
      • 这是对称的:对于任何非空参考值 xy,当且仅当 y.equals(x) 返回 true 时,x.equals(y) 应返回 true
      • 这是transitive:对于任何非空引用值 xyz ,如果 x.equals(y) 返回 true 并且 y.equals(z) 返回 true ,那么 x.equals(z) 应该返回 true
      • 这是持续的:对于任何非空引用值 xyx.equals(y) 的多次调用一致地返回 true 或一致地返回 false ,前提是在对象的 equals 比较中使用的信息没有被修改。
      • 对于任何非空参考值 xx.equals(null) 应该返回 false

      等价关系将其操作的元素划分为等价类;等价类的所有成员彼此相等。等价类的成员可以相互替代,至少出于某些目的。

      API 注意:
      每当重写该方法时,通常都需要重写 hashCode 方法,以维护 hashCode 方法的通用契约,该契约规定相等的对象必须具有相等的哈希码。
      实现要求:
      Objectequals 方法实现了对象上最具辨别力的可能等价关系;也就是说,对于任何非空引用值 xy,此方法返回 true 当且仅当 xy 引用同一对象(x == y 具有值 true )。也就是说,在引用相等等价关系下,每个等价类只有一个元素。
      参数:
      obj - 要比较的参考对象。
      返回:
      true 如果此对象与 obj 参数相同; false否则。
      参见:
    • 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 方法的子类也可以抛出此异常以指示无法克隆实例。
      参见:
    • toString

      public String  toString()
      返回对象的字符串表示形式。
      API 注意:
      通常,toString 方法返回一个“文本表示”此对象的字符串。结果应该是简洁但信息丰富的表示形式,易于人们阅读。建议所有子类重写此方法。随着时间的推移或跨 JVM 调用,字符串输出不一定稳定。
      实现要求:
      ObjecttoString 方法返回一个字符串,该字符串由对象是其实例的类的名称、at 符号字符“@”和对象哈希码的无符号十六进制表示形式组成。换句话说,此方法返回一个等于以下值的字符串:
       getClass().getName() + '@' + Integer.toHexString(hashCode())
       
      返回:
      对象的字符串表示形式。
    • notify

      public final void notify()
      唤醒在此对象的监视器上等待的单个线程。如果有任何线程正在等待该对象,则选择唤醒其中一个线程。选择是任意的,由实现自行决定。线程通过调用 wait 方法之一在对象的监视器上等待。

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

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

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

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

      抛出:
      IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
      参见:
    • notifyAll

      public final void notifyAll()
      唤醒在此对象的监视器上等待的所有线程。线程通过调用 wait 方法之一在对象的监视器上等待。

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

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

      抛出:
      IllegalMonitorStateException - 如果当前线程不是此对象监视器的所有者。
      参见:
    • wait

      public final void wait() throws InterruptedException
      导致当前线程等待直到被唤醒,通常是 notifiedinterrupted

      在所有方面,此方法的行为就像调用了 wait(0L, 0) 一样。有关详细信息,请参阅 wait(long, int) 方法的规范。

      抛出:
      IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者
      InterruptedException - 如果在当前线程等待之前或期间有任何线程中断了当前线程。抛出该异常时,当前线程的interrupted status被清空。
      参见:
    • wait

      public final void wait(long timeoutMillis) throws InterruptedException
      导致当前线程等待直到它被唤醒,通常是被 notifiedinterrupted 唤醒,或者直到经过一定的实时时间。

      在所有方面,此方法的行为就像调用了 wait(timeoutMillis, 0) 一样。有关详细信息,请参阅 wait(long, int) 方法的规范。

      参数:
      timeoutMillis - 最长时间等待,以毫秒为单位
      抛出:
      IllegalArgumentException - 如果 timeoutMillis 为负
      IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者
      InterruptedException - 如果在当前线程等待之前或期间有任何线程中断了当前线程。抛出该异常时,当前线程的interrupted status被清空。
      参见:
    • wait

      public final void wait(long timeoutMillis, int nanos) throws InterruptedException
      导致当前线程等待直到它被唤醒,通常是被 notifiedinterrupted 唤醒,或者直到经过一定的实时时间。

      当前线程必须拥有该对象的监视器锁。请参阅 notify 方法,了解线程可以成为监视器锁所有者的方式的描述。

      此方法会导致当前线程(此处称为T) 将自己置于该对象的等待集中,然后放弃对该对象的所有同步声明。请注意,只有此对象上的锁被放弃;当前线程可能同步的任何其他对象在线程等待时保持锁定状态。

      线T然后出于线程调度目的而被禁用并处于休眠状态,直到发生以下情况之一:

      • 一些其他线程为此对象和线程调用 notify 方法T恰好被任意选择为要被唤醒的线程。
      • 一些其他线程为此对象调用 notifyAll 方法。
      • 一些其他线程 中断 线程T.
      • 指定的实时时间或多或少已经过去。实际时间量(以纳秒为单位)由表达式 1000000 * timeoutMillis + nanos 给出。如果 timeoutMillisnanos 都为零,则不考虑实时,线程等待直到被其他原因之一唤醒。
      • 线T被虚假地唤醒。 (见下文。)

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

      一个线程可以在没有被通知、中断或超时的情况下被唤醒,这就是所谓的 spurious wakeup 。虽然这在实践中很少发生,但应用程序必须通过测试应该导致线程被唤醒的条件来防止它,如果条件不满足则继续等待。请参见下面的示例。

      有关此主题的更多信息,请参阅 Brian Goetz 和其他人的第 14.2 节“条件队列”Java 并发实践(Addison-Wesley, 2006) 或 Joshua Bloch 的第 81 项有效的 Java,第三版(艾迪生 - 卫斯理,2018 年)。

      如果当前线程在等待之前或等待期间被任何线程interrupted,则抛出InterruptedException。抛出该异常时,当前线程的interrupted status被清空。在如上所述恢复此对象的锁定状态之前,不会抛出此异常。

      API 注意:
      推荐的等待方法是在对 wait 的调用周围的 while 循环中检查正在等待的条件,如下例所示。除其他外,这种方法避免了可能由虚假唤醒引起的问题。
      
         synchronized (obj) {
           while (<condition does not hold> and <timeout not exceeded>) {
             long timeoutMillis = ... ; // recompute timeout values
             int nanos = ... ;
             obj.wait(timeoutMillis, nanos);
           }
           ... // Perform action appropriate to condition or timeout
         }
        
      参数:
      timeoutMillis - 最长时间等待,以毫秒为单位
      nanos - 附加时间,以纳秒为单位,在 0-999999 范围内(含)
      抛出:
      IllegalArgumentException - 如果 timeoutMillis 为负,或者 nanos 的值超出范围
      IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者
      InterruptedException - 如果在当前线程等待之前或期间有任何线程中断了当前线程。抛出该异常时,当前线程的interrupted status被清空。
      参见:
    • finalize

      @Deprecated (since ="9", forRemoval =true) protected void finalize() throws Throwable
      已弃用,将被删除:此 API 元素可能会在未来版本中删除。
      Finalization 已弃用,并可能在未来的版本中删除。使用终结可能会导致安全性、性能和可靠性方面的问题。有关讨论和备选方案,请参阅 JEP 421

      覆盖 finalize 以执行清理的子类应使用替代清理机制并删除 finalize 方法。当对象变得不可访问时,使用 Cleaner PhantomReference 作为释放资源的更安全方式。或者,添加一个 close 方法来显式释放资源,并实现 AutoCloseable 以启用 try -with-resources 语句。

      在从大多数现有代码中删除终结器之前,此方法将保持不变。

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

      在已禁用或删除终结的 Java 虚拟机中运行时,垃圾收集器永远不会调用 finalize() 。在启用终结的 Java 虚拟机中,垃圾收集器可能仅在无限期延迟后才调用 finalize

      finalize 的一般契约是,当 Java 虚拟机确定不再有任何方法可以通过任何尚未死亡的线程访问此对象时调用它,除非是采取操作的结果通过完成其他一些准备完成的对象或类。 finalize 方法可以采取任何行动,包括使该对象再次可用于其他线程;然而,finalize 的通常目的是在对象被不可撤销地丢弃之前执行清理操作。例如,表示输入/输出连接的对象的 finalize 方法可能会执行显式 I/O 事务以在对象被永久丢弃之前断开连接。

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

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

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

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

      finalize 方法抛出的任何异常都会导致此对象的终结停止,但会被忽略。

      API 注意:
      嵌入非堆资源的类有许多选项可用于清理这些资源。该类必须确保每个实例的生命周期都长于它嵌入的任何资源的生命周期。 Reference.reachabilityFence(java.lang.Object) 可用于确保在对象中嵌入的资源正在使用时对象仍然可以访问。

      子类应避免覆盖 finalize 方法,除非子类嵌入了必须在收集实例之前清理的非堆资源。与构造函数不同,终结器调用不会自动链接。如果子类重写 finalize,它必须显式调用超类终结器。为了防止异常过早终止终结链,子类应使用 try-finally 块以确保始终调用 super.finalize()。例如,

         @Override
         protected void finalize() throws Throwable {
           try {
             ... // cleanup subclass state
           } finally {
             super.finalize();
           }
         }
        
      抛出:
      Throwable - 此方法引发的 Exception
      Java 语言规范:
      12.6 类实例的终结
      参见: