jdk-Object类

简言：Object是所有类的父类，经常会用到hashcode，equals方法。对这个父类也有一点好奇，就简单看看Object，做下记录。
基于jdk1.8，通过目录可以看到Object属于java.lang包下的类。

整体类

通过快捷方式Alt + 7,可以查看类的整体结构

package java.lang;

/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {
    /**
    *registerNatives是一个native方法。它的实现不是在java中完成。是由
    *C/C++完成，并被编译成.dll文件，由java调用。
    */
    private static native void registerNatives();
    static {
       //在静态代码块中，类加载就执行
        registerNatives();
    }

  /**
  *获取运行时的类的类型
  */
    public final native Class<?> getClass();

   /**
    *1.程序运行期间，对同一对象多次调用hashcode方法时，必须返回相同的整数。(对象进行equals比较时所用
    *的信息没有被修改)
    *2.如果根据equals方法，两个对象相等，这两个对象中的每个对象调用hashcode方法都必须生成相同的整数
    *3.如果根据equals方法，两个对象不相等，不要求生成的hashcode一定不同。
    *hashcode用于校验对象的哈希值，这个值的作用是检索。
    */
    public native int hashCode();

    /**
     * equasl用于确定两个对象是否相同
     * 哈希值相同的对象不一定equals为true
     * equals返回true，两个对象义定相同
     * 这个比较的是对象的内存地址
     * String的equals重写了Obeject的equals，比较的是对象的值
     * 
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /**
     * 用于对象的复制
     * clone函数返回一个引用，指向的是新的clone出来的对象
     * 此对象与原对象分别占用不同的堆空间
     */
    protected native Object clone() throws CloneNotSupportedException;

    /**
     * 返回对象的字符串表示
     * getClass().getName()获取全路径名称如java.lang.Object
     * Integer.toHexString将哈希值转成16进制格式的字符串
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     * 通知等待系列函数
     * 在使用Synchronize语句中使用，用于唤醒在改对象的监视器上等待的单个线程
     */
    public final native void notify();

    /**
     * 通知等待系列函数
     * 在使用Synchronize语句中使用，用于唤醒在改对象的监视器上等待的所有线程
     */
    public final native void notifyAll();

    /**
     * 通知等待系列函数
     * 在使用Synchronize语句中使用，当前线程必须拥有此对象监视器，改线程发布对此监视器的所有权并等待
     * 直到其他线程通过调用notify方法或者notifyAll方法通知在此对象的监视器上等待的线程醒来
     * 或者等待timeout时间后，线程醒来
     * 然后改线程等到通知重新获取对监视器的所有权后才能继续执行
     */
    public final native void wait(long timeout) throws InterruptedException;

     /**
     * 通知等待系列函数
     * 在使用Synchronize语句中使用，让当前线程等待直到另一个线程调用此对象的notify()或者
     * notifyAll()方法，或者其他某个线程中断当前线程，或者过去了一定的时间
     * nanos不能大于等于10000000ms即1000s
     */
    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);
    }

    /**
     * 通知等待系列函数
     * 在使用Synchronize语句中使用，让当前线程等待直到另一个线程调用此对象的notify()或者  
     * notifyAll()方法通知在此对象的监听器上等待的线程，然后改线程将等到重新获的对监视器的所有权后才
     * 能继续执行
     */
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /**
     * 当垃圾回收器确定改对象没有被应用时，调用此方法
     */
    protected void finalize() throws Throwable { }
}

核心方法

equals方法

我们也经常听别人问equals与 == 运算符的区别。
==运算符用于比较基本类型的值是否相同。
equals用于比较两个对象是否相等。

基本类型比较，我们都比较了解。对象是否相同是怎么比较的呢？
源码中如下；

public boolean equals(Object obj) {
        return (this == obj);
    }

在Object中equals和==是一样的。如果两个对象的引用相同，那么equals就是相同的。我们看看String类中的equals方法。

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

判断地址值是否相同，如果相等返回true。
如果不相等，判断内容长度是否相等，每个字符是否相同(区分大小写)，相等返回true，否则返回fallse。

注意：
  无论何时重写此方法，通常都必须重写hashCode方法，以维护hashCode方法的一般约定，该方法声明相等对象必须具有相同的哈希代码。

hashcode

public native int hashCode();

hashcode是要给被native修饰的方法。方法返回对象的哈希值。
它有什么作用呢？
  感觉就是在使用HashSet，HashMap以及HashTable等，在插入数据时保证元素不可重复，同时为了提高元素的插入删除便捷效率而设计的。为了查找的便捷性而存在。
举例：
  我们往Set集合中存数据，Set集合的特性就是数据不重复。如果每次插入都通过equals进行比较的话，如果数据量有十万，百万级别，效率是非常慢的。
  如果我们添加数据的时候使用哈希表，哈希算法也称为散列算法，当添加一个值的时候先算出它的哈希值，根据算出的哈希值将数据插入指定位置。这样就避免了一直调用equals造成的效率隐患。有以下几种情况：

1. 如果位置为空，则直接添加
2. 如果位置不为空，判断两个元素是否相同，如果相同则不存储。
3. 如果位置元素不相同，但是hashcode相同，这种情况属于哈希碰撞。如果hash key相同，就把相同的元素创建一个链表，把所有相同的元素存放到链表中。

getClass方法

这个方法被native修饰，返回类的类型。
这个方法被final修饰，不能被重写。

toString方法

 /**
     * 返回对象的字符串表示
     * getClass().getName()获取全路径名称如java.lang.Object
     * Integer.toHexString将哈希值转成16进制格式的字符串
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

很明显就是把返回的类的全限定名 + 16进制无符号整数形式哈希码的字符串。