Java中Object类的十二种方法及作用

Object是Java所有类的基类，是整个类继承结构的顶端，我们几乎每次都需要使用到它。
Object的12种方法分别是：registerNatives()、getClass()、hashCode()、equals()、clone()、toString()、wait()、wait(long)、wait(long,int)、notify()、notifyAll()、finalize()。下面对这些方法做一个总结归纳。

registerNatives()

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

这个方法是一个注册本地方法，由JVM实现，底层是C/C++实现的，由代码我们可以发现一个问题，为什么要使用静态方法，还要放在静态块中呢？
原因是类初始化的顺序是：
父类–静态变量/父类–静态初始化块
子类–静态变量/子类–静态初始化块
父类–变量/父类–初始化块
父类–构造器
子类–变量/子类–初始化块
子类–构造器
放入静态代码块中保证了父类的类变量及方法的初始化一定先于子类，所以当子类调用响应native方法，比如计算hashCode()时，一定可以保证能够调用到JVM的native方法。

getClass()

public final native Class<?> getClass();

这是一个 public的方法，我们可以直接通过对象调用。
类加载的第一阶段类的加载就是将 .class文件加载到内存，并生成一个 java.lang.Class对象的过程。 getClass()方法就是获取这个对象，这是当前类的对象在运行时类的所有信息的集合。这个方法是反射三种方式之一(类名.class、对象.getClass、Class.forName("全类名"))。

hashCode()

public native int hashCode();

这是一个 public的方法，所以子类可以重写它。这个方法返回当前对象的 hashCode值，这个值是一个整数范围内的 （-2^31~2^31-1）数字。
对于 hashCode有以下几点约束:

1. 在 Java应用程序执行期间，在对同一对象多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是将对象进行 equals 比较时所用的信息没有被修改；
2. 如果两个对象 x.equals(y) 方法返回 true，则 x、 y这两个对象的 hashCode必须相等。
3. 如果两个对象 x.equals(y) 方法返回 false，则 x、 y这两个对象的 hashCode可以相等也可以不等。但是，为不相等的对象生成不同整数结果可以提高哈希表的性能。
4. 默认的 hashCode是将内存地址转换为的 hash值，重写过后就是自定义的计算方式；也可以通过 System.identityHashCode(Object)来返回原本的 hashCode。

equals()

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

用于比较当前对象与目标对象是否相等，默认是比较引用是否指向同一对象。为 public方法，子类可重写。

为什么需要重写 equals方法？

因为如果不重写equals方法，当将自定义对象放到 map或者 set中时；如果这时两个对象的 hashCode相同，就会调用 equals方法进行比较，这个时候会调用 Object中默认的 equals方法，而默认的 equals方法只是比较了两个对象的引用是否指向了同一个对象，显然大多数时候都不会指向，这样就会将重复对象存入 map或者 set中。这就破坏了 map与 set不能存储重复对象的特性，会造成内存溢出。

重写 equals方法的几条约定：

1. 自反性：即 x.equals(x)返回 true， x不为 null；
2. 对称性：即 x.equals(y)与 y.equals(x）的结果相同， x与 y不为 null；
3. 传递性：即 x.equals(y)结果为 true, y.equals(z)结果为 true，则 x.equals(z)结果也必须为 true；
4. 一致性：即 x.equals(y)返回 true或 false，在未更改 equals方法使用的参数条件下，多次调用返回的结果也必须一致。 x与 y不为 null。
5. 如果 x不为 null, x.equals(null)返回 false。

clone()

protected native Object clone() throws CloneNotSupportedException;

此方法返回当前对象的一个副本。

这是一个 protected方法，提供给子类重写。但需要实现 Cloneable接口，这是一个标记接口，如果没有实现，当调用 object.clone()方法，会抛出 CloneNotSupportedException。

@Override    
protected CloneTest clone() throws CloneNotSupportedException
{
    return （CloneTest) super.clone();
}

那如果我们要进行深拷贝怎么办呢？
答案是：如果成员变量是引用类型，想实现深拷贝，则成员变量也要实现 Cloneable接口，重写 clone方法。

toString()

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

这是一个 public方法，子类可重写，建议所有子类都重写 toString方法，默认的 toString方法，只是将当前类的全限定性类名 +@+十六进制的 hashCode值。

wait()/ wait(long)/ wait(long,int)

public final native void wait(long timeout) 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);
}


public final void wait() throws InterruptedException {
        wait(0);
}

这三个方法是用来线程间通信用的，作用是阻塞当前线程，等待其他线程调用 notify()/notifyAll()方法将其唤醒。这些方法都是 publicfinal的，不可被重写。

注意：

1. 此方法只能在当前线程获取到对象的锁监视器之后才能调用，否则会抛出 IllegalMonitorStateException异常。
2. 调用 wait方法，线程会将锁监视器进行释放；而 Thread.sleep，Thread.yield()并不会释放锁。
3. wait方法会一直阻塞，直到其他线程调用当前对象的 notify()/notifyAll()方法将其唤醒；而 wait(long)是等待给定超时时间内（单位毫秒），如果还没有调用 notify()/nofiyAll()会自动唤醒； wait(long,int)如果第二个参数大于 0并且小于 999999，则第一个参数 +1作为超时时间；

notify()/notifyAll()

public final native void notify();

public final native void notifyAll();

前面说了，如果当前线程获得了当前对象锁，调用 wait方法，将锁释放并阻塞；这时另一个线程获取到了此对象锁，并调用此对象的 notify()/notifyAll()方法将之前的线程唤醒。这些方法都是 publicfinal的，不可被重写。

publicfinalnativevoidnotify(); 随机唤醒之前在当前对象上调用 wait方法的一个线程
publicfinalnativevoidnotifyAll(); 唤醒所有之前在当前对象上调用 wait方法的线程

注意：调用 notify()后，阻塞线程被唤醒，可以参与锁的竞争，但可能调用 notify()方法的线程还要继续做其他事，锁并未释放，所以我们看到的结果是，无论 notify()是在方法一开始调用，还是最后调用，阻塞线程都要等待当前线程结束才能开始。

finalize

 protected void finalize() throws Throwable { }

此方法是在垃圾回收之前，JVM会调用此方法来清理资源。此方法可能会将对象重新置为可达状态，导致JVM无法进行垃圾回收。永远不要主动调用某个对象的 finalize()方法，该方法由垃圾回收机制自己调用；

感谢codesheep!