Object类精讲

1. 概 览

Object是java所有类的基类，是整个类继承结构的顶端，也是最抽象的一个类。大家天天都在使用toString()、equals()、hashCode()、wait()、notify()、getClass()等方法，或许都没有意识到是Object的方法，也没有去看Object还有哪些方法以及思考为什么这些方法要放到 Object中。本篇就每个方法具体功能、重写规则以及自己的一些理解。

2. Object类所有方法详解

Object中含有：registerNatives()、getClass()、hashCode()、equals()、clone()、toString()、notify()、notifyAll()、wait(long)、wait(long,int)、wait()、finalize()共十二个方法。这个顺序是按照Object类中定义方法的顺序列举的，下面我也会按照这个顺序依次进行讲解。

2.1 registerNatives()

public class Object {
	private static native void registerNatives();
    static {
        registerNatives();
    }
}

从名字上理解，这个方法是注册native方法（本地方法，由JVM实现，底层是C/C++实现的）向谁注册呢？当然是向JVM，当有程序调用到native方法时，JVM才好去找到这些底层的方法进行调用。

Object中的 native方法，并使用registerNatives()向JVM进行注册。（这属于JNI的范畴，有兴趣的可自行查阅。）

为什么要使用静态方法，还要放到静态块中呢？

我们知道了在类初始化的时候，会依次从父类到本类的类变量及类初始化块中的类变量及方法按照定义顺序放到< clinit>方法中，这样可以保证父类的类变量及方法的初始化一定先于子类。所以当子类调用相应native方法，比如计算hashCode时，一定可以保证能够调用到 JVM的native方法。

2.2 getClass()

public final native Class getClass();

这是一个public的方法，我们可以直接通过对象调用。

类加载的第一阶段类的加载就是将.class文件加载到内存，并生成一个java.lang.Class对象的过程。getClass()方法就是获取这个对象，这是当前类的对象在运行时类的所有信息的集合。这个方法是反射三种方式之一。

3.3 hashCode()

public native int hashCode();

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

对于hashCode有以下几点约束:

• 在Java应用程序执行期间，在对同一对象多次调用hashCode方法时，必须一致地返回相同的整数，前提是将对象进行equals 比较时所用的信息没有被修改；

• 如果两个对象x.equals(y)方法返回true，则x、 y这两个对象的 hashCode必须相等。

• 如果两个对象x.equals(y)方法返回false，则x、 y这两个对象的 hashCode可以相等也可以不等。但是，为不相等的对象生成不同整数结果可以提高哈希表的性能。

• 默认的hashCode是将内存地址转换为的hash值，重写过后就是自定义的计算方式；也可以通过System.identityHashCode(Object)来返回原本的hashCode。

public class HashCodeTest{
    private int age;
    private String name;
    
    @Override
    public int hashCode() {
        Object[] a = Stream.of(age, name).toArray();
        int result = 1;
        for (Object element : a) {
            result = 31 * result + (element == null ? 0 : element.hashCode());
        }
        return result;
    }
}

推荐使用Objects.hash(Object…values)方法。相信看源码的时候，都看到计算hashCode都使用了31作为基础乘数，为什么使用31呢？我比较赞同与理解result*31=(result<<5)-result。 JVM底层可以自动做优化为位运算，效率很高；还有因为31计算的hashCode冲突较少，利于hash桶位的分布。

3.4 equals()

public boolean equals(Object obj);

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

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

为什么需要重写equals方法？

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

重写equals方法的几条约定：

• 自反性：即x.equals(x)返回 true，x不为 null；

• 对称性：即x.equals(y)与y.equals(x）的结果相同， x与y不为 null；

• 传递性：即x.equals(y)结果为true,y.equals(z)结果为true，则 x.equals(z)结果也必须为true；

• 一致性：即x.equals(y)返回true或false，在未更改equals方法使用的参数条件下，多次调用返回的结果也必须一致。x与y不为null。

• 如果x不为null,x.equals(null)返回false。

3.5 clone()

protected native Object clone() throws CloneNotSupportedException;

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

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

public class CloneTest implements Cloneable {
    private int age;
    private String name;
    //省略get、set、构造函数等    
    @Override    
    protected CloneTest clone() throws CloneNotSupportedException{
        return (CloneTest) super.clone();
    }
    public static void main(String[] args) throws CloneNotSupportedException {
        CloneTest cloneTest = new CloneTest(23, "XX"); 
        CloneTest clone = cloneTest.clone();
        System.out.println(clone == cloneTest);
        System.out.println(cloneTest.getAge()==clone.getAge());
        System.out.println(cloneTest.getName()==clone.getName());
    }
}

//输出结果
false
true
true

从输出我们看见，clone的对象是一个新的对象；但原对象与clone对象的String类型的name却是同一个引用，这表明，super.clone方法对成员变量如果是引用类型，进行是浅拷贝。

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

3.6 toString()

public String toString()；

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

我们思考一下为什么需要toString方法？

可以这么理解：返回当前对象的字符串表示，可以将其打印方便查看对象的信息，方便记录日志信息提供调试。我们可以选择需要表示的重要信息重写到toString方法中。

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

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

注意：

• 此方法只能在当前线程获取到对象的锁监视器之后才能调用，否则会抛出IllegalMonitorStateException异常。

• 调用wait方法，线程会将锁监视器进行释放；而 Thread.sleep，Thread.yield()并不会释放锁。

• wait方法会一直阻塞，直到其他线程调用当前对象的 notify()/notifyAll()方法将其唤醒；而wait(long)是等待给定超时时间内（单位毫秒），如果还没有调用notify()/nofiyAll()会自动唤醒； wait(long,int)如果第二个参数大于0并且小于999999，则第一个参数+1作为超时时间；

3.8 notify()/notifyAll()

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

• public final native void notify();随机唤醒之前在当前对象上调用wait方法的一个线程

• public final native void notifyAll();唤醒所有之前在当前对象上调用wait方法的线程

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

为什么wait()/notify()方法要放到Object中呢？ 因为每个对象都可以成为锁监视器对象，所以放到Object中，可以直接使用。

3.9 finalize()

protected void finalize() throws Throwable ;

此方法是在垃圾回收之前，JVM会调用此方法来清理资源。此方法可能会将对象重新置为可达状态，导致JVM无法进行垃圾回收。

我们知道java相对于C++很大的优势是程序员不用手动管理内存，内存由jvm管理；如果我们的引用对象在堆中没有引用指向他们时，当内存不足时，JVM会自动将这些对象进行回收释放内存，这就是我们常说的垃圾回收。但垃圾回收没有讲述的这么简单。

finalize()方法具有如下4个特点：

• 永远不要主动调用某个对象的finalize()方法，该方法由垃圾回收机制自己调用；

• finalize()何时被调用，是否被调用具有不确定性；

• 当JVM执行可恢复对象的finalize()可能会将此对象重新变为可达状态；

• 当 JVM执行finalize()方法时出现异常，垃圾回收机制不会报告异常，程序继续执行。