Object源碼閱讀記錄

public class Object {

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

    /**
     * 返回對象的運行時類
     * 用例：Number n = 0
     * Class<? extends Number> c = n.getClass();
     */
    public final native Class<?> getClass();

    /**
     * 返回對象的hash值，本方法爲支持哈希表提供了不少好處，例如:hashmap中
     * 1.當一個java應用執行時，一個相同的對象屢次調用hashcode方法，這個方法都會返回相同的
     * 整數
     * 2.根據equals方法，若是兩個對象相等，則這兩個對象調用hashcode方法必須生成一樣的hash值
     * 3.根據equals方法，若是兩個對象不相等，則這兩個對象調用hashcode方法必將生成不一樣的hash值,
     * 注意：兩個對象的hashcode值相等，兩個對象用equals比較並不必定相等
     * 程序員應該意識到，爲不一樣的對象生成不一樣的hash值將會提升hash表的性能
     * @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     java.lang.System#identityHashCode
     */
    public native int hashCode();

    /**
     * 比較兩個對象相等
     * 自反性（reflextive）：對於任何非空的引用值x，x.equals(x)都會返回true
     * 對稱性（symmetric）：對於任何的非空引用值x和y,只有當y.equals(x)返回true時，x.equals(y)才爲true
     * 傳遞性（transitive）：對於任何的非空引用值x和y、z，若是x.equals(y)返回true,y.equals(z)返回true,
     * 那麼x.equals(z)也將返回true
     * 一致性（consistent）:對於任何非空的引用x和y,屢次調用x.equals(y)始終返回true或者false的前提是
     * equal比較中全部的信息未被修改
     * 對於任何的非空引用值x,x.equals(null)始終返回false
     * 只有當x,y指向同一個對象時，則x==y纔會返回true
     * 若是必需要從新equals方法，那麼一般也須要重寫hashcode方法，根據hashcode方法的協議規範
     * 兩個相同的對象必須具備相同的hash碼
     * @param   obj   the reference object with which to compare.
     * @return  {@code true} if this object is the same as the obj
     *          argument; {@code false} otherwise.
     * @see     #hashCode()
     * @see     java.util.HashMap
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /**
     * 該克隆屬於淺克隆
     * 建立並返回對象的一個副本，副本意味着依賴對對象的類
     * 一般的狀況：對於任何一個對象x;若是表達式：
     * x.clone() != x 返回true
     * 那麼 x.clone().getClass() == x.getClass()也將返回true
     * 但這不是絕對條件，通常狀況下：
     * x.clone().equals(x)也將返回true
     * 依照約定，返回的對象應該經過調用super.clone()得到，若是
     * 若是一個類或者他的全部超類(除object)都遵循此約定，則
     * x.clone().getClass() == x.getClass()
     * 按照約定，此方法返回的對象應該獨立於該對象(被克隆的對象)，要想實現這種獨立性
     * 在supper.clone()返回以前修改他的一個或者多個字段，這一般意味着
     * 要複製包含正在被克隆對象的內部「深層結構」的全部可變對象，並使用對副本的引用
     * 替換對這些對象的引用，若是一個類只包含基本字段或者是引用的對象是不可變的，
     * 那麼一般不須要修改super.clone()返回的對象
     * Object類的clone方法執行特定的克隆操做，若是一個類沒有實現cloneable接口
     * 將會拋出CloneNotSupportedException.
     * 注意：全部對象都被視爲實現了cloneable接口，不然，此方法會建立此對象的類的一個新實例，
     * 並像經過分配那樣，嚴格使用此對象相應字段的內容初始化該對象的全部字段；
     * 這些字段的內容沒有被自我克隆。因此，此方法執行的是該對象的「淺表複製」，而不「深層複製」操做
     * Object自己沒有實現cloneable接口，所以自身調用object將會在運行時拋出異常
     *
     * @return     a clone of this instance.
     * @see java.lang.Cloneable
     */
    protected native Object clone() throws CloneNotSupportedException;

    /**
     * 對象以字符串形式返回，結果是易讀的，推薦全部的子類都從新該方法
     * Object的toString方法返回一個字符串，該字符串有類名+@+此對象哈希碼的無符號十六進制表示組成
     * 換句話說，此方法返回的值等價於：
     * getClass().getName()+'@'+Integer.toHexString(hashCode())
     * @return  a string representation of the object.
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     * 喚醒在此對象上監聽等待單個線程，若是全部線程都在這個對象上等待，
     * 他們中的其中一個會被喚醒，選擇是任意性的，並在實現作出決定時發生，
     * 一個線程經過調用wait方法，在對象的監聽器上等待
     * 直到當前的線程的放棄在該對象上的鎖，被喚醒的線程將以常規方式與該對象上的其餘線程競爭
     * 例如，喚醒的線程在做爲鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。
     * 此方法只應由做爲此對象監視器的全部者的線程來調用。經過如下三種方法之一，線程能夠成爲此對象監視器的全部者：
     * 經過執行此對象的同步 (Sychronized) 實例方法。
     * 經過執行在此對象上進行同步的 synchronized 語句的正文。
     * 對於 Class 類型的對象，能夠經過執行該類的同步靜態方法。
     * 一次只能有一個線程擁有對象的監視器。
     *
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @see        java.lang.Object#notifyAll()
     * @see        java.lang.Object#wait()
     */
    public final native void notify();

    /**
     * 喚醒在此對象監聽器上等待的全部線程，線程經過調用wait方法在該對象的監聽器上
     * 等待，被喚醒的線程不能直接執行，直到當前的線程放棄在該對象上的鎖。
     * 例如，喚醒的線程在做爲鎖定此對象的下一個線程方面沒有可靠的特權或劣勢。 
     * 此方法只應由做爲此對象監視器的全部者的線程來調用。經過如下三種方法之一，線程能夠成爲此對象監視器的全部者： 
     * 經過執行此對象的同步 (Sychronized) 實例方法。 * 經過執行在此對象上進行同步的 synchronized 語句的正文。
     *
     */
    public final native void notifyAll();

    /**
     * 致使線程等待，直到其餘的線程條用該對象上的notify()或者是notifyAll()方法，或者是超過指定的時間
     * 當前的線程必須擁有此對象的監聽器
     * 此方法致使當前線程（稱之爲 T）將其自身放置在對象的等待集中，
     * 而後放棄此對象上的全部同步要求。出於線程調度目的，線程 T 被禁用，且處於休眠狀態，直到發生如下四種狀況之一：
     * 其餘一些線程調用該對象的notify方法，而且線程T被任選爲被喚醒線程
     * 其餘一些線程調用該對象的notifyAll()方法
     * 其餘一些線程中斷線程T
     *
     * @param      timeout   等待時間.
     */
    public final native void wait(long timeout) throws InterruptedException;

    /**
     *
     * @param      timeout   須要等待的時間.
     * @param      nanos     額外時間, in nanoseconds range
     *                       0-999999.
     * @exception  IllegalArgumentException      if the value of timeout is
     *                      negative or the value of nanos is
     *                      not in the range 0-999999.
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @exception  InterruptedException if any thread interrupted the
     *             current thread before or while the current thread
     *             was waiting for a notification.  The <i>interrupted
     *             status</i> of the current thread is cleared when
     *             this exception is thrown.
     */
    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 >= 500000 || (nanos != 0 && timeout == 0)) {
            timeout++;
        }

        wait(timeout);
    }

    /**
     * 默認的wait方法
     */
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /**
     * 當垃圾收集器肯定該對象沒有被更多引用時，有該對象的垃圾回收器調用
     * 子類重寫改方法已配置資源或者執行其餘清除操做
     * finalize 的常規協定是：當 JavaTM 虛擬機已肯定還沒有終止的任何線程沒法再經過任何方法訪問此對象時，
     * 將調用此方法，除非因爲準備終止的其餘某個對象或類的終結操做執行了某個操做。
     * finalize 方法能夠採起任何操做，其中包括再次使此對象對其餘線程可用；
     * 不過，finalize 的主要目的是在不可撤消地丟棄對象以前執行清除操做。
     * 例如，表示輸入/輸出鏈接的對象的 finalize 方法可執行顯式 I/O 事務，以便在永久丟棄對象以前中斷鏈接。
     * Object 類的 finalize 方法執行非特殊性操做；它僅執行一些常規返回。Object 的子類能夠重寫此定義。
     * Java 編程語言不保證哪一個線程將調用某個給定對象的 finalize 方法。
     * 但能夠保證在調用 finalize 時，調用 finalize 的線程將不會持有任何用戶可見的同步鎖定。
     * 若是 finalize 方法拋出未捕獲的異常，那麼該異常將被忽略，而且該對象的終結操做將終止。
     * 在啓用某個對象的 finalize 方法後，將不會執行進一步操做，
     * 直到 Java 虛擬機再次肯定還沒有終止的任何線程沒法再經過任何方法訪問此對象，
     * 其中包括由準備終止的其餘對象或類執行的可能操做，在執行該操做時，對象可能被丟棄。
     * 對於任何指定對象java虛擬機只調用一次finalize()方法
     * @throws Throwable the {@code Exception} raised by this method
     */
    protected void finalize() throws Throwable { }
}