[Java] Object类中方法解析

一  概述

　　Object是java所有类的基类，是整个类继承结构的顶端，也是最抽象的一个类。

　　Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。所有的类都直接或者间接的继承自Object类。该类的设计也符合面向对象中"万事万物皆对象"的思想。

　　构造方法

　　public Object()

　　任何一个类都会调用这个方法，访问子类构造方法的首先会先访问父类无参的构造方法。

二  Object方法详解

　　Object中含有：registerNatives()、getClass()、hashCode()、equals()、clone()、toString()、notify()、notifyAll()、wait(long)、wait(long,int)、wait()、finalize()共十二个方法。

　　这个顺序是按照Object类中定义方法的顺序列举的，下面也会按照这个顺序依次进行讲解。

1   registerNatives()方法

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

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

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

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

2  getClass()方法

　　public final native Class<?> getClass();

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

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

　　获取类的Class对象的三种方式：

　　（1）对象的getClass();

　　（2）类名.class；

　　（3）Class.forName(“类全限定名”);

3  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可以相等也可以不等。

　　但是，为不相等的对象生成不同整数结果可以提高哈希表的性能。 默认的hashCode是将内存地址转换为的hash值，重写过后就是自定义的计算方式；也可以通过System.identityHashCode(Object)来返回原本的hashCode。

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

　　public static int hashCode(Object var0) {
        return var0 != null ? var0.hashCode() : 0;
    }

4  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方法使用的参数条件下，多次调用返回的结果也必须一致。

　　（5）x与y不为null。 如果x不为null, x.equals(null)返回false。

　　查看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;
    }

　　建议equals及hashCode两个方法，需要重写时，两个都要重写，一般都是将自定义对象放至Set中，或者Map中的key时，需要重写这两个方法。

　　假如只重写equals而不重写hashCode，那么自定义类的hashCode方法默认就是继承父类Object的hashCode方法，由于默认的hashCode方法是根据对象的内存地址经过hash算法得来的，因此可能会导致u1对象和u2对象两个对象的equals方法为true，但是hashCode值不一定相等，这个时候将该对象作为HashMap的key就会出现问题，跟期望的不一致(两个对象equals，却存在MashMap的两个槽上)。

　　并且重写了equals，且u1.equals(u2)返回true，根据hashcode的规则，两个对象相等其哈希值一定相等，所以矛盾就产生了，因此重写equals一定要重写hashcode，而且重写后返回的新的哈希值与自定义类的equals使用的的属性有关。

　　两个对象相等，hashcode一定相等

　　两个对象不等，hashcode不一定不等

　　hashcode相等，两个对象不一定相等

　　hashcode不等，两个对象一定不等

5   clone()方法

　　protected native Object clone() throws CloneNotSupportedException;

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

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

@Data
public class CloneTest implements Cloneable {
    private int age;
    private String name;

    public CloneTest(int age, String name) {
        this.age = age;
        this.name = name;
    }

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

    public static void main(String[] args) throws CloneNotSupportedException {
        CloneTest cloneTest = new CloneTest(23, "9龙");
        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方法对成员变量如果是引用类型，进行是浅拷贝。

　　那什么是浅拷贝？对应的深拷贝？

　　　　浅拷贝：拷贝的是引用。

　　　　深拷贝：新开辟内存空间，进行值拷贝。

　　在浅克隆中，如果原型对象的成员变量是值类型，将值复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。

　　浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制，那如果我们要进行深拷贝怎么办呢？看下面的例子。

class Person implements Cloneable{
    private int age;
    private String name;
     //省略get、set、构造函数等
     @Override
    protected Person clone() throws CloneNotSupportedException {
        Person person = (Person) super.clone();
        //name通过new开辟内存空间
        person.name = new String(name);
        return person;
   }
}

public class CloneTest implements Cloneable {
    private int age;
    private String name;
    //增加了person成员变量
    private Person person;

    //省略get、set、构造函数等
    @Override
    protected CloneTest clone() throws CloneNotSupportedException {
        CloneTest clone = (CloneTest) super.clone();
        clone.person = person.clone();
        return clone;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
       CloneTest cloneTest = new CloneTest(23, "9龙");
        Person person = new Person(22, "路飞");
        cloneTest.setPerson(person);

        CloneTest clone = cloneTest.clone();
        System.out.println(clone == cloneTest);
        System.out.println(cloneTest.getAge() == clone.getAge());
        System.out.println(cloneTest.getName() == clone.getName());

        Person clonePerson = clone.getPerson();
        System.out.println(person == clonePerson);
        System.out.println(person.getName() == clonePerson.getName());
    }
}

　　如果成员变量是引用类型，想实现深拷贝，则成员变量也要实现Cloneable接口，重写clone方法。

6  toString()方法

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

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

7   wait()/ wait(long)/ waite(long,int)

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

　　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);
    }

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

　　这些方法都是public final的，不可被重写。

　　注意： 此方法只能在当前线程获取到对象的锁监视器之后才能调用，否则会抛出IllegalMonitorStateException异常，即必须在synchronize代码块中执行。

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

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

8  notify()/notifyAll()

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

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

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

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

　　为什么wait()/notify()方法要放到Object中呢？

　　因为每个对象都可以成为锁监视器对象，所以放到Object中，可以直接使用。

9  finalize()

protected void finalize() throws Throwable { }

　　此方法是在垃圾回收之前，JVM会调用此方法来清理资源。

　　此方法可能会将对象重新置为可达状态，导致JVM无法进行垃圾回收。

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

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

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

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

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

　　对象在内存中存在三种状态：

　　（1）可达状态：有引用指向，这种对象为可达状态；

　　（2）可恢复状态：失去引用，这种对象称为可恢复状态；垃圾回收机制开始回收时，回调用可恢复状态对象的finalize()方法（如果此方法让此对象重新获得引用，就会变为可达状态，否则，会变为不可达状态）。

　　（3）不可达状态：彻底失去引用，这种状态称为不可达状态，如果垃圾回收机制这时开始回收，就会将这种状态的对象回收掉。

 　　在jvm垃圾回收过程中，一个对象的finalize只会被执行一次，如果再次进行垃圾回收时，判断该对象的finalize已经被执行过，则不再执行finalize方法。

10  finalize()方法，finally关键字,final关键字的区别?

　　finalize()方法：

当垃圾回收器确定不存在对该对象的更多引用时， 由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。

　　final：

final修饰的变量表示常量，不能够被二次赋值 。
final修饰的类不能够被继承 。
final修饰的方法不能够被子类重写。

　　finally：

Java 中的 Finally 关键一般与try一起使用，在程序进入try块之后，无论程序是因为异常而中止或其它方式返回终止的，finally块的内容一定会被执行 。
特殊情况：在执行到finally之前jvm退出了（比如System.exit(0)）。
作用：用于释放资源，在IO流操作和数据库操作中常见到。

参考:

　　https://www.cnblogs.com/fzxey/p/10759234.html

　　https://www.cnblogs.com/JonaLin/p/11051982.html