JDK源码阅读一Object源码分析

最近经过某大佬的建议准备阅读一下 JDK 的源码来提升一下自己

所以开始写 JDK 源码分析的文章

阅读 JDK 版本为 1.8

---

• 目录

  • Object 结构图
  • 构造器
  • equals 方法
  • getClass 方法
  • hashCode 方法
  • toString 方法
  • finalize 方法
  • registerNatives 方法

---

1. Object 结构图

2. 类构造器

  类构造器是创建 Java 对象的方法之一。一般我们都使用 new 关键字来进行实例，还可以在构造器中进行相应的初始化操作。

  在一个 Java 类中必须存在一个构造器，如果没有添加系统在编译时会默认创建一个无参构造。

/* 实例一个 Object 对象 */
Object obj = new Object()

3. equals 方法

  在面试中面试官经常会问 equals() 方法和 == 运算符的区别，== 运算符用于比较基本类型的值是否相同而 equals 用于比较两个对象是否相等，那么有个问题来了，两个对象怎么才算是相等的呢。
看 object 中的 equals 实现

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

在 Object 中 equals 和 == 是等价的。所以在 Object 中两个对象的引用相同，那么一定就是相同的。在我们自定义对象的时候一定要重写 equals 方法。我参考了以下网上的资料来分析一下 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;
    }

String 是引用类型，比较时不能比较引用是否相等，重点是字符串的内容是否相等。所以 String 类定义两个对象相等的标准是字符串内容都相同。

在 Java 规范中，对 equals 方法的使用必须遵循以下几个原则：

• 自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
• 对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
• 传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
• 一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改
• 对于任何非空引用值 x，x.equals(null) 都应返回 false

下面定义一个类，在这个类中重写 equals 方法 对象属性相同则相等 否则不相等

public class Student {
    private String name;

    /**
     * 无参构造方法
     */
    public Student() {}

    /**
     * 无参构造方法
     */
    public Student(String name) {this.name = name;}
    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    @Override
    public boolean equals(Object obj) {
        // 引用相同 两个对象肯定是相同的
        if(this==obj){return true;}
        // 对象等于空 或者不是 Student 是不想等的
        if(obj==null || !(obj instanceof Student)){return false;}
        // 转为 Student 对象
        Student student = (Student)obj;
        // 属性相同 返回 true
        return this.getName()==student.getName();
    }

}

然后创建一个测试类来进行测试:

        Student t1 = new Student("yes");
        Student t2 = new Student("slm");
        System.out.println("对象不同 属性不同 =="+(t1==t2));
        System.out.println("对象不同 属性不同 equals"+(t1.equals(t2)));
        Student t3 = new Student("slm");
        System.out.println("对象不同 属性相同"+(t2.equals(t3)));

输出结果:

对象不同 属性不同 == false

对象不同 属性不同 equals false

对象不同 属性相同 true

现在可以看出 如果在这里不重写 equals 方法的话永远只会执行 Object 的 equals 也就是通过 == 对比对象引用地址是否相同。

下面再看一个例子，这个时候如果出现一个 Student 的子类我们在对比一下

/**
 * @Author: sunluomeng
 * @CreateTime: 2019-06-06 23:35
 * @Description:
 */
public class Language  extends Student{
    private String name;

    /**
     * 无参构造
     */
    public Language(){}

    /**
     * 有参构造
     * @param name
     */
    public Language(String name){this.name=name;}

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    @Override
    public boolean equals(Object obj) {
        // 引用相同 两个对象肯定是相同的
        if(this==obj){return true;}
        // 对象等于空 或者不是 Student 是不想等的
        if(obj==null || !(obj instanceof Language)){return false;}
        // 转为 Student 对象
        Language language = (Language)obj;
        // 属性相同 返回 true
        return this.getName()==language.getName();
    }

}

这个时候我们的新创建的 Language 类继承 Student 然后创建两个对象去做比较

输出结果:

父类对比子类 属性相同 —true

子类对比父类 属性相同 —false

可以看出父类去对比子类既 student.equals(language) 结果为 true 而子类去对比父类 既 language.equals(student) 返回 false

这样的话就违反了问哦们上面说到的对称性

对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true

如果 y 是 Student x 是 Language
那么现在就是 y.equals(x) 等于 true 反过来 x.equals(y) 也应该返回 true，但是现在为什么会返回 false 呢？

先来看一下代码

我们在判断的时候使用了 instanceof 关键字来判断运行的时候是否是指定的类型

java 中的 instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof 通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。

这样的话也就是说 Language 是 Student 的子类 在用 instanceof 判断的时候是返回 true, 而 Language 虽然是继承 Student 但是使用 instanceof 判断的时候会发现 Language 和 Student 的类型不同 然后 Student 也不是 Language 的子类所以会返回 false。

而解决的办法就是

然后我们在运行一下刚刚的代码

输出结果:

父类对比子类 属性相同 —false

子类对比父类 属性相同 —false

完美解决，满足对称性

注意: 使用 getClass 是要根据情况而定，使用 getClass 不符合多态的定义

那什么时候使用 instanceof，什么时候使用 getClass 呢？

• 如果子类能够拥有自己的相等概念，则对称性需求将强制采用 getClass 进行检测。
• 如果有超类决定相等的概念，那么就可以使用 instanceof 进行检测，这样可以在不同的子类的对象之间进行相等的比较。

还有就是一定要注意无论何时重写此方法，通常都必须重写 hashCode 方法，以维护 hashCode 方法的一般约定，该方法声明相等对象必须具有相同的哈希代码。

4.getClass 方法

我们首先看一下 getClass 在 Object 中的实现。

我们看到 getClass 被 native 标识，这代表这是调用本地方法实现

关于 native 更多请百度。native 是由操作系统帮我们实现

文档说明的是调用 getClass 返回一个运行时的类。什么意思呢 我们看下面的代码实现。

打印结果:

可以看出 getClass 是返回一个运行时的对象。class 是返回编译的类对象

可以看到 getClass 方法被 final 修饰，说明此方法不能被重写。

5.hashCode

先看一下 hashCode 在 Object 中的实现：

hashCode 也是一个被 native 修饰的本地方法

注释说明的是返回该对象的哈希值。那么它有什么作用呢？

主要是保证基于散列的集合，如 HashSet、HashMap 以及 HashTable 等，在插入元素时保证元素不可重复，同时为了提高元素的插入删除便利效率而设计；主要是为了查找的便捷性而存在。

就比如使用 Set 进行举例子。

Set 集合是不可重复的，如果每次添加数据都使用 equals 去做对比的话，插入十万条数据就要对比十万次效率是非常慢的。

所以在添加数据的时候使用了哈希表，哈希算法也称之为散列算法，当添加一个值的时候先算出它的哈希值根据算出的哈希值将数据插入指定位置。这样的话就避免了一直调用 equals 造成的效率隐患。同时有以下条件：

• 如果位置为空则直接添加
• 如果位置不为空，判断两个元素是否相同如果相同则不存储。

还有一种情况是两个元素不相同，但是 hashCode 相同，这就是哈希碰撞。

如果发生了 hash key 相同的情况就在相同的元素创建一个链表。把所有相同的元素存放在链表中。

可以看出 T1 的哈希和 T2 相同，但是元素不同，所以现在会形成一个链来存储。

6.toString

先看 toString 的实现

可以看出 toString 是返回的类名加 16 进制无符号整数形式返回此哈希码的字符串表示形式。

运行输出结果:

直接输出对象和使用 toString 是一样的

如果想要 toString 输出属性内容则需要重写 toString 方法

7.finalize

源码中实现方法:

finalize 用户垃圾回收是由 JVM 调用。

8.registerNatives

源码实现：

上面说到 native 是调用本地实现方法，而 registerNatives 则是对本地方法注册，装载本地库。在 Object 初始化时执行。

还有 notify()/notifyAll()/wait() 等写到多线程的时候在做分析

最后

小弟不才，如有错误请指出。喜欢请关注，慢慢更新 JDK 源码阅读笔记

小弟公众号，乱敲代码。欢迎点赞, 关注

---