模块  java.base
软件包  java.lang

Class Object

  • public class Object
    类Object是类层次结构的根。 每个班级都有Object作为超类。 所有对象（包括数组）都实现此类的方法。
    从以下版本开始：
    1.0
    另请参见：
    类

    • 构造方法摘要

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

    • 方法摘要

      所有方法  实例方法 具体的方法  弃用的方法 
      变量和类型 方法 描述
      protected Object clone()
      创建并返回此对象的副本。
      boolean equals​(Object obj)
      指示某个其他对象是否“等于”此对象。
      protected void finalize()
      已过时。
      最终确定机制本质上存在问题。
      类<?> getClass()
      返回此 Object的运行时类。
      int hashCode()
      返回对象的哈希码值。
      void notify()
      唤醒正在此对象监视器上等待的单个线程。
      void notifyAll()
      唤醒等待此对象监视器的所有线程。
      String toString()
      返回对象的字符串表示形式。
      void wait()
      导致当前线程等待它被唤醒，通常是 通知或 中断 。
      void wait​(long timeoutMillis)
      导致当前线程等待它被唤醒，通常是 通知或 中断 ，或者直到经过一定量的实时。
      void wait​(long timeoutMillis, int nanos)
      导致当前线程等待它被唤醒，通常是 通知或 中断 ，或者直到经过一定量的实时。

    • 构造方法详细信息

      • Object

        public Object()
        构造一个新对象。

    • 方法详细信息

      • getClass

        public final 类<?> getClass()
        返回此Object的运行时类。 返回的类对象是由所表示的类的static synchronized方法锁定的对象。

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

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

        结果
        类对象，表示此对象的运行时类。
        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方法在非null对象引用上实现等价关系：

        • 自反性 ：对于任何非空的参考值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 。

        类Object的equals方法实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值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返回的对象中的任何字段。

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

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

        结果
        这个实例的克隆。
        异常
        CloneNotSupportedException - 如果对象的类不支持Cloneable接口。 覆盖clone方法的子类也可以抛出此异常以指示无法克隆实例。
        另请参见：
        Cloneable

      • toString

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

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

         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 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方法。
        • 一些其他线程interrupts线程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，第二版中的第69项（Addison-Wesley，2008） ）。

        如果当前线程在等待之前或之前由任何线程为interrupted ，则抛出InterruptedException 。 抛出此异常时，将清除当前线程的中断状态 。 在如上所述恢复此对象的锁定状态之前，不会抛出此异常。

        API Note:
        推荐的等待方法是检查while循环中正在等待的条件，调用wait ，如下例所示。 除此之外，这种方法避免了可能由虚假唤醒引起的问题。 
           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 - 如果任何线程在当前线程等待之前或当前线程中断当前线程。 抛出此异常时，将清除当前线程的中断状态 。
        另请参见：
        notify() ， notifyAll() ， wait() ， wait(long)

      • finalize

        @Deprecated(since="9")
protected void finalize()
                 throws Throwable
        Deprecated.
        The finalization mechanism is inherently problematic. Finalization can lead to performance issues, deadlocks, and hangs. Errors in finalizers can lead to resource leaks; there is no way to cancel finalization if it is no longer necessary; and no ordering is specified among calls to finalize methods of different objects. Furthermore, there are no guarantees regarding the timing of finalization. The finalize method might be called on a finalizable object only after an indefinite delay, if at all. Classes whose instances hold non-heap resources should provide a method to enable explicit release of those resources, and they should also implement AutoCloseable if appropriate. The Cleaner and PhantomReference provide more flexible and efficient ways to release resources when an object becomes unreachable.
        当垃圾收集确定没有对该对象的更多引用时，由对象上的垃圾收集器调用。 子类重写finalize方法以处置系统资源或执行其他清理。

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

        类Object的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