java.lang.Object 翻译

package java.lang;

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

    private static native void registerNatives();
    static {
        registerNatives();
    }

    /**
     * 返回运行时类此的Object 。 返回Class对象是受锁定对象static synchronized所表示的类的方法。
     * 实际结果的类型是Class<? extends |X|> Class<? extends |X|>其中|X| 是静态类型上其表达的擦除getClass被调用。 例如，没有铸造在该代码片段必需的：
     * Number n = 0; Class<? extends Number> c = n.getClass();
     * @return
     */
    public final native Class<?> getClass();

    /**
     * 返回该对象的哈希码值。 被支撑为哈希表的益处此方法例如通过所提供的那些java.util.HashMap 。
     * 的一般合同hashCode是：
     * 每当它是一个Java应用程序的执行期间，在同一对象上调用一次以上，所述hashCode方法必须一致地返回相同的整数，没有提供在所使用的信息equals上的对象被修改的比较。 该整数不必从一个应用的执行保持一致，以同一应用程序的另一执行。
     * 如果两个对象根据相等equals(Object)方法，然后调用hashCode在各两个对象的方法必须产生相同的整数结果。
     * 这不是必需的：如果两个对象根据不相等Object.equals(Object)方法，然后调用hashCode方法在各两个对象的必须产生不同的整数结果。 但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。
     * 尽可能合理地实用，由类定义的hashCode方法Object并返回针对不同的对象不同的整数。 （这一般是通过将该对象的内部地址转换成一个整数来实现的，但不是由Java™编程语言不需要这种实现技巧。）
     * @return
     */
    public native int hashCode();

    /**
     * 指示某个其他对象是否“等于”这一项。
     * 该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 ，此方法返回true当且仅当x和y指代相同的对象（ x == y的值为true ）。
     * 请注意，这是通常需要覆盖hashCode每当这个方法被覆盖的方法，从而保持对一般合同hashCode方法，其中指出相等的对象必须具有相同的散列码。
     * @param obj
     * @return
     */
    
    public boolean equals(java.lang.Object obj) {
        return (this == obj);
    }

    /**
     * 创建并返回此对象的副本。 的“副本”的准确含义可能依赖于对象的类。 总的意图是，对于任何对象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 ，所以调用clone的对象，它的类是方法Object将导致在运行时抛出异常。
     * @return
     * @throws CloneNotSupportedException
     */
    protected native java.lang.Object clone() throws CloneNotSupportedException;

    /**
     * 返回该对象的字符串表示。 通常， toString方法返回一个字符串“以文本表示”该对象。 其结果应是一个简明而丰富的表示，这样便于人们阅读。 建议所有子类重写此方法。
     * 所述toString用于类方法Object返回一个由其中的对象是一个实例，该符号字符`的类的名称的字符串@ ”，并且对象的哈希码的无符号的十六进制表示。 换句话说，此方法返回一个字符串等于的值：
     *        getClass().getName() + '@' + Integer.toHexString(hashCode())
     * @return
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     * 唤醒在此对象监视器上等待的单个线程。 如果任何线程此对象上等待，它们中的一个被选择为被唤醒。 选择是任意的，并在执行的自由裁量权发生。 线程通过调用的一个对象的监视器上等待wait的方法。
     * 唤醒的线程将无法继续进行，直到当前线程放弃此对象的锁。 被唤醒的线程将在与可能，积极争相此对象上进行同步的任何其他线程通常的方式竞争; 例如，唤醒的线程在享有作为一个线程锁定这个对象没有可靠的特权或劣势。
     * 此方法只能由一个线程，它是此对象监视器的所有者被调用。 线程成为三种方式之一的对象监视器的所有者：
     * 通过执行对象的同步实例方法。
     * 通过执行体synchronized的对象上进行同步的语句。
     * 对于类型的对象Class,通过执行该类的同步静态方法。
     * 一次只能有一个线程拥有对象的监视器。
     */
    public final native void notify();

    /**
     * 唤醒在等待该对象的监视器上的全部线程。 线程通过调用的一个对象的监视器上等待wait的方法。
     * 被唤醒的线程将无法继续进行，直到当前线程放弃此对象的锁。 被唤醒的线程将在与可能，积极争相此对象上进行同步的任何其他线程通常的方式竞争; 例如，唤醒的线程享受成为下一个线程锁定这个对象没有可靠的特权或劣势。
     * 此方法只能由一个线程，它是此对象监视器的所有者被调用。 看到notify了，其中一个线程能够成为监视器所有者的方法的描述方法。
     */
    public final native void notifyAll();

    /**
     * 使当前的线程等待直到其他线程调用Object.notify()方法或Object.notifyAll()方法用于此目的，或者在指定的时间量已过去。
     * 当前线程必须拥有该对象的监视器。
     * 此方法导致当前线程（称之为T）将自身此对象的等待集中，然后放弃此对象上的任何和所有权利要求的同步。 线程t出于线程调度目的，禁用并一直处于休眠状态的四两件事发生对象：
     * 一些其它线程调用notify此对象的方法和缝线T碰巧被任意地选择为被唤醒线程。
     * 其他某些线程调用notifyAll此对象的方法。
     * 其他某个线程中断线程t。
     * 实时指定量已过去，或多或少。 如果timeout为零，然而，然后实时不考虑和线程只是等待通知。
     * 的缝线T然后从该对象的等待集合中移除和重新启用用于线程调度。 然后，它在竞争与其他线程用于向对象上同步右侧的通常的方式; 一旦获得了对象的控制，对象上的所有其同步索赔恢复到原状-也就是说，到局势的是，时间wait方法被调用。 缝线T然后从的调用返回wait方法。 因此，从返回wait方法中，对象和线程的同步状态T正是因为它是当wait被调用的方法。
     * 线程还可以唤醒不被通知，中断，或超时，所谓虚假唤醒 。 虽然这会在实际中很少出现，应用程序必须通过测试为已经导致线程被唤醒的条件，并继续等待，如果条件不成立防范它。 换句话说，等待应总是发生在循环中，像这样的：
     *            synchronized (obj) {
     *                while (<condition does not hold>)
     *                    obj.wait(timeout);
     *                ... // Perform action appropriate to condition
     *            }
     *
     * （有关此主题的更多信息，请参见3.2.3节在Doug Lea的“使用Java并发编程（第二版）”（Addison-Wesley出版社，2000），或第50条在约书亚布洛赫的“有效的Java编程语言指南”（艾迪生韦斯利，2001）。
     * 如果当前线程被中断任何线程之前或在等待时，那么InterruptedException被抛出。 没有引发此异常，直到如上所述的该对象的锁定状态已经恢复。
     * 请注意， wait的方法，因为它当前线程放入等待此对象设置，解锁仅此对象; 而线程等待在其上当前线程可以被同步的任何其他对象保持锁定。
     * 此方法只能由一个线程，它是此对象监视器的所有者被调用。 看到notify了，其中一个线程能够成为监视器所有者的方法的描述方法。
     * @param timeout
     * @throws InterruptedException
     */
    public final native void wait(long timeout) throws InterruptedException;

    /**
     * 导致当前线程等待，直到其他线程调用Object.notify()方法或Object.notifyAll()此对象的方法，或一些其它线程中断当前线程，或一定量的真实时间已过。
     * 这种方法类似于wait一个参数的方法，但它允许随着时间的量在放弃之前等待通知更好的控制。 的实时的量，以纳秒为单位测得的，由下式给出：
     *        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
     *            }
     *
     * 此方法只能由一个线程，它是此对象监视器的所有者被调用。 看到notify了，其中一个线程能够成为监视器所有者的方法的描述方法。
     * @param timeout
     * @param nanos
     * @throws InterruptedException
     */
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                    "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

    /**
     * 导致当前线程等待，直到其他线程调用Object.notify()方法或Object.notifyAll()此对象的方法。 换句话说，此方法的行为就好像它简单地执行呼叫wait(0)
     * 当前线程必须拥有该对象的监视器。 这款显示器并等待线程释放所有权，直到另一个线程通知等候在这个对象监视器上的通过电话或者醒来的notify方法或notifyAll方法。 该线程将等到重新获得对监视器的所有权后才能继续执行。
     * 如在一个参数的版本，中断和杂散唤醒是可能的，而且这种方法应该总是在一个循环中使用：
     *            synchronized (obj) {
     *                while (<condition does not hold>)
     *                    obj.wait();
     *                ... // Perform action appropriate to condition
     *            }
     *
     * 此方法只能由一个线程，它是此对象监视器的所有者被调用。 看到notify了，其中一个线程能够成为监视器所有者的方法的描述方法。
     * @throws InterruptedException
     */
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /**
     * 通过在对象上的垃圾收集器调用时垃圾回收器确定不存在于对象的更多引用。 子类覆盖finalize方法，以配置系统资源或执行其他清理。
     * 的一般合同finalize的是，它被调用，如果和当Java™虚拟机已确定不再有通过这个对象可以通过还没有死，只是作为一个动作而产生的任何线程访问的任何手段通过一些其它对象或类，其准备被完成的最后确定服用。 的finalize方法可以采取任何行动，包括再制作该对象提供给其他线程; 通常的目的finalize ，但是，是执行清理操作之前的对象被不可逆转地丢弃。 例如，对于表示输入/输出连接可能执行显式I / O事务中断连接前的物体永久丢弃对象finalize方法。
     * 在finalize类的方法， Object不进行任何特殊的动作; 它只是正常返回。 的子类Object可以覆盖这个定义。
     * Java编程语言不保证哪个线程将调用finalize方法对于任何给定的对象。 但可以保证的是，线程调用完成不会持有任何用户可见的同步锁被调用时敲定。 如果未捕获的异常是由finalize方法抛出，异常被忽略，并且该对象的终止定稿。
     * 在之后finalize方法被调用的对象，没有进一步采取行动，直到Java虚拟机再次确定不再有通过这个对象可以通过尚未终止的任何线程，包括可能采取的行动进行访问的任何手段由其他对象或已准备好最后确定的类，在该点的对象可被丢弃。
     * 在finalize方法永远不会对任何给定对象多次调用由Java虚拟机。
     * 被抛出的任何异常finalize方法导致停止此对象的终结，否则忽略。
     * @throws Throwable
     */
    protected void finalize() throws Throwable { }
}