Object对象你真理解了吗？
前言
五一回家又断更了一个放假时间了~~~
只有光头才能变强
回顾前面：
之前花了点之间时间去搞多线程的基础知识了，难呀难呀难呀….打算还写一篇线程池的就暂时将多线程系列停止了…
今天中午在逛简书的时候发现一些大厂也会问Object对象里面有什么方法(也算是一个知识点吧)，Object我还没去认真复习过，于是这篇主要看看Object对象有什么要注意的地方~
那么接下来就开始吧，如果文章有错误的地方请大家多多包涵，不吝在评论区指正哦~
一、Object对象简介
声明：本文都是使用JDK1.8
我们学Java的知道，Java是一门面向对象的语言。无论在Java中出现什么，都可以认为它是对象(除了八大基本数据类型。当然了，八大基本数据类型也能装箱成为对象)：
而Object就是这些对象的最高级别的，所有的Java对象都隐式地继承了Object对象(不用显示写
extends继承)所有的Java对象都拥有Object默认的方法。
那么我们看看Object有什么方法：
其实就可以归纳成几个：
registerNatives()【底层实现、不研究】hashCode()equals(Object obj)clone()toString()notify()notifyAll()wait(long timeout)【还有重载了两个】finalize()
Object一共有11个方法，其中一个为底层的实现registerNatives()，其中两个wait()和wait(long timeout, int nanos)重载方法。
所以我们真正需要看的就是8个方法
还有一个属性：
public final native Class<?> getClass();
二、equals和hashCode方法
equals和hashCode方法可以说是面试的重点题了，配合着String可以说在面试题中哪都有它们的存在。
首先，我们来看看equals和hashCode在Object中原生的实现吧：
hashCode：
public native int hashCode();
equals：
public boolean equals(Object obj) {
return (this == obj);
}
看上去都非常简单：
hashCode()由native方法底层实现了。equals()就直接==判断是否相等了。
想要更加清晰它们究竟是做什么的，我们来读读它的注释：
根据注释我们可以总结以下的要点：
重写
equals()方法，就必须重写hashCode()的方法equals()方法默认是比较对象的地址，使用的是==等值运算符hashCode()方法对底层是散列表的对象有提升性能的功能同一个对象(如果该对象没有被修改)：那么重复调用
hashCode()那么返回的int是相同的！hashCode()方法默认是由对象的地址转换而来的equals()方法还有5个默认的原则：自反性--->调用
equals()返回的是true，无论这两个对象谁调用equals()都好，返回的都是true一致性--->只要对象没有被修改，那么多次调用还是返回对应的结果！
传递性--->
x.equals(y)和y.equals(z)都返回true，那么可以得出：x.equals(z)返回true对称性--->
x.equals(y)和y.equals(x)结果应该是相等的。传入的参数为null，返回的是false
为啥说hashCode()以散列表为底层带来性能的提升是很容易理解的。我们再来回顾一下HashMap的插入：
如果hash值都不相等，那么可以直接判断该key是不相等的了！
2.1equals和hashCode方法重写
equals()方法默认是比较对象的地址，使用的是==等值运算符。但是按我们正常开发来说，比较的是对象地址是没有意义的。
一般地，如果我们有两个Address对象，只要这两个对象的省号、城市号、街道号相等，我们就认为这两个对象相等了！
2.2String实现的equals和hashCode方法
我们在初学的时候可能就听过了：String已经实现了equals和hashCode方法了。
这也就是为什么，我们可以直接使用String.equals()来判断两个字符串是否相等！
下面我们就来看看它的实现吧：
三、toString方法
接下来我们看看toString方法，也十分简单：
toString方法主要是用来标识该对象的：
从上面的结果我们都可以看出来：得出的结果我们并不能看到什么东西~
于是我们一般都重写toString()，那么打印出的结果就很方便我们调试了！
@Override
public String toString() {
return "Address{" +
"provinceNo=" + provinceNo +
", cityNo=" + cityNo +
", streetNo=" + streetNo +
'}';
}
下面的结果看起来就好多了：
四、clone方法
我们也来看看它的顶部注释：
看了上面的注释我们可以总结以下的要点：
clone方法用于对象的克隆，一般想要克隆出的对象是独立的(与原有的对象是分开的)
深拷贝指的是该对象的成员变量(如果是可变引用)都应该克隆一份，浅拷贝指的是成员变量没有被克隆一份
下面我们来看一下浅拷贝：拷贝了Employee对象，但是其成员变量hireday没有被克隆出去，所以指向的还是同一个Date对象！
4.1clone用法
那么我们如何克隆对象呢？无论是浅拷贝还是深拷贝都是这两步：
克隆的对象要实现Cloneable接口
重写clone方法，最好修饰成public
浅拷贝：仅仅拷贝了Person对象，而date没有拷贝！
public class Person implements Cloneable {
// 可变的成员变量
private Date date;
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
深拷贝：不仅拷贝了Person对象，也拷贝了date成员变量
public class Person implements Cloneable {
// 可变的成员变量
public Date date;
@Override
public Object clone() throws CloneNotSupportedException {
// 拷贝Person对象
Person person = (Person) super.clone();
// 将可变的成员变量也拷贝
person.date = (Date) date.clone();
// 返回拷贝的对象
return person;
}
}
4.2clone疑问进一步学习protected
不知道有没有人跟我有相同的疑问：
我只想要浅拷贝，能不能直接调用该对象.clone()来实现？
比如我现在有个Address对象：
public class Address {
private int provinceNo;
private int cityNo;
private int streetNo;
public Address() {
}
public Address(int provinceNo, int cityNo, int streetNo) {
this.provinceNo = provinceNo;
this.cityNo = cityNo;
this.streetNo = streetNo;
}
}
下面的代码你们认为如何？
Address address = new Address(1, 2, 3);
address.clone();
我们都知道：
protected修饰的类和属性,对于自己、本包和其子类可见
可能会想：clone()方法是定义在Object类上的(以protected来修饰)，而我们自定义的Address对象隐式继承着Object(所有的对象都是Object的子类)，那么子类调用Object以protected来修饰clone()是完全没问题的
但是，IDE现实告诉我，这编译就不通过了！
出现错误的原因我立马就想到：是不是我对protected修饰符出现了偏差？
protected修饰的类和属性,对于自己、本包和其子类可见，这句话本身是没有错的。但是还需要补充：对于protected的成员或方法，要分子类和超类是否在同一个包中。与基类不在同一个包中的子类，只能访问自身从基类继承而来的受保护成员，而不能访问基类实例本身的受保护成员。
上面的代码就错在：Address与Object不是在同一个包下的，而Address直接访问了Object的clone方法。这是不行的。
下面我截两张图再来给你们看看(看完图再看上面的描述，就能理解了)：
图片来源和更多的展开阅读：https://blog.csdn.net/wangyanguiyiyang/article/details/49800493
五、wait和notify方法
wait和notify方法其实就是Java给我们提供让线程之间通信的API。
按照惯例我们还是来看注释怎么说吧：
wait方法：
notify方法：
notifyAll()方法：
看完上面的注释我们可以总结以下的要点：
无论是wait、notify还是notifyAll()都需要由监听器对象(锁对象)来进行调用
简单来说：他们都是在同步代码块中调用的，否则会抛出异常！
notify()唤醒的是在等待队列的某个线程(不确定会唤醒哪个)，notifyAll()唤醒的是等待队列所有线程导致
wait()的线程被唤醒可以有4种情况该线程被中断
wait()时间到了被
notify()唤醒被
notifyAll()唤醒调用
wait()的线程会释放掉锁
其实总结完上面的并不会有比较深刻的印象，可以尝试着回答几个问题来加深对wait()和notify()的理解。
5.1为什么wait和notify在Object方法上？
从一开始我们就说了：wait()和notify()是Java给我们提供线程之间通信的API，既然是线程的东西，那什么是在Object类上定义，而不是在Thread类上定义呢？
因为我们的锁是对象锁【要是忘记的同学可回顾：Java锁机制了解一下】，每个对象都可以成为锁。让当前线程等待某个对象的锁，当然应该通过这个对象来操作了。
锁对象是任意的，所以这些方法必须定义在Object类中
5.2notify方法调用后，会发生什么？
上面已经说了，notify会唤醒某个处于等待队列的线程。
但是要注意的是：
notify方法调用后，被唤醒的线程不会立马获得到锁对象。而是等待notify的synchronized代码块执行完之后才会获得锁对象
5.3sleep和wait有什么区别？
Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权。
主要的区别在于
Object.wait()在释放CPU同时，释放了对象锁的控制。而
Thread.sleep()没有对锁释放
参考资料：
https://blog.csdn.net/lingzhm/article/details/44940823
http://www.cnblogs.com/dolphin0520/p/3920385.html
https://www.cnblogs.com/eer123/p/7880789.html
https://www.jianshu.com/p/f4454164c017
六、finalize()方法
finalize()方法将在垃圾回收器清除对象之前调用，但该方法不知道何时调用，具有不定性
一般我们都不会重写它~
一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。
参考资料：
https://segmentfault.com/q/1010000000094660
进阶的资料：
https://www.cnblogs.com/Smina/p/7189427.html
http://www.importnew.com/23913.html
https://zhuanlan.zhihu.com/p/29522201
https://zhuanlan.zhihu.com/p/25698745
七、总结
总的来说也算是把Object看了一遍了，不至于一下子把它的方法给忘了~~~在学习的过程中也遇到过问题，最明显的是对protected修饰符又加深了一次理解。
参考资料：
《Java核心技术卷一》
如果文章有错的地方欢迎指正，大家互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y。为了大家方便，刚新建了一下qq群：742919422，大家也可以去交流交流。谢谢支持了！希望能多介绍给其他有需要的朋友
文章的目录导航：
https://zhongfucheng.bitcron.com/post/shou-ji/wen-zhang-dao-hang