Object对象你真理解了吗？

时间 2019-11-29

标签 object 对象真理解了繁體版

原文原文链接

前言

五一回家又断更了一个放假时间了~~~html

只有光头才能变强java

回顾前面：面试

以前花了点之间时间去搞多线程的基础知识了，难呀难呀难呀....打算还写一篇线程池的就暂时将多线程系列中止了...c#

今天中午在逛简书的时候发现一些大厂也会问Object对象里面有什么方法(也算是一个知识点吧)，Object我还没去认真复习过，因而这篇主要看看Object对象有什么要注意的地方~segmentfault

那么接下来就开始吧，若是文章有错误的地方请你们多多包涵，不吝在评论区指正哦~微信

1、Object对象简介

声明：本文都是使用JDK1.8多线程

咱们学Java的知道，Java是一门面向对象的语言。不管在Java中出现什么，均可以认为它是对象(除了八大基本数据类型。固然了，八大基本数据类型也能装箱成为对象)：ide

而Object就是这些对象的最高级别的，全部的Java对象都隐式地继承了Object对象(不用显示写extends继承)
全部的Java对象都拥有Object默认的方法。

那么咱们看看Object有什么方法：post

其实就能够概括成几个：性能

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

复制代码

2、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()来判断两个字符串是否相等！

下面咱们就来看看它的实现吧：

3、toString方法

接下来咱们看看toString方法，也十分简单：

toString方法主要是用来标识该对象的：

从上面的结果咱们均可以看出来：得出的结果咱们并不能看到什么东西~

因而咱们通常都重写toString()，那么打印出的结果就很方便咱们调试了！

@Override
    public String toString() {
        return "Address{" +
                "provinceNo=" + provinceNo +
                ", cityNo=" + cityNo +
                ", streetNo=" + streetNo +
                '}';
    }
复制代码

下面的结果看起来就好多了：

4、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方法。这是不行的。

下面我截两张图再来给大家看看(看完图再看上面的描述，就能理解了)：

图片来源和更多的展开阅读：blog.csdn.net/wangyanguiy…

5、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()没有对锁释放

参考资料：

6、finalize()方法

finalize()方法将在垃圾回收器清除对象以前调用，但该方法不知道什么时候调用，具备不定性

通常咱们都不会重写它~

一个对象的finalize()方法只会被调用一次，并且finalize()被调用不意味着gc会当即回收该对象，因此有可能调用finalize()后，该对象又不须要被回收了，而后到了真正要被回收的时候，由于前面调用过一次，因此不会调用finalize()，产生问题。

参考资料：

segmentfault.com/q/101000000…

进阶的资料：

7、总结

总的来讲也算是把Object看了一遍了，不至于一会儿把它的方法给忘了~~~在学习的过程当中也遇到过问题，最明显的是对protected修饰符又加深了一次理解。

参考资料：

《Java核心技术卷一》

若是文章有错的地方欢迎指正，你们互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同窗，能够关注微信公众号:Java3y。

文章的目录导航：

zhongfucheng.bitcron.com/post/shou-j…