java SEjava 源码阅读 —— Object

Posted 2021-01-11 莫问今朝

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java SEjava 源码阅读 —— Object相关的知识，希望对你有一定的参考价值。

看源码也不太懂怎么看，Object类的 java 代码很少，方法实现都靠 C/C++ ，主要看注释，然后自己理解。有不对的地方请指正

1. 概览

import jdk.internal.HotSpotIntrinsicCandidate;

/**
 * native 关键字修饰的方法：
 * 1. 没有方法体
 * 2. 将调用C/C++实现的方法（可以搜索一下JNI）
 */
public class Object {

    /**
     * 这个方法使JVM能找到本地的方法（C/C++实现的方法）
     */
    private static native void registerNatives();
    static {
        registerNatives();
    }


    /**
     * 空构
     */
    @HotSpotIntrinsicCandidate
    public Object() {}


    /**
     * 关键字 native， 调用的是 C/C++ 实现的方法
     * 关键字 final，不允许被子类重写
     * 获得该对象运行时的Class类的实例
     *
     */
    @HotSpotIntrinsicCandidate
    public final native Class<?> getClass();


    /**
     * 关键字 native
     * 返回 对象的散列值
     * 允许重写（常被重写）
     */
    @HotSpotIntrinsicCandidate
    public native int hashCode();


    /**
     *判断两个对象是否相等
     *常被重写
     */
    public boolean equals(java.lang.Object obj) {
        return (this == obj);
    }


    /**
     * 创建并返回对象的一个副本（拷贝）
     * 关键字 native
     * 关键字 protected
     */
    @HotSpotIntrinsicCandidate
    protected native java.lang.Object clone() throws CloneNotSupportedException;


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


    /**
     * 唤醒一个正在等待该资源的线程
     * 关键字 final
     * 关键字 native
     */
    @HotSpotIntrinsicCandidate
    public final native void notify();


    /**
     * 唤醒所有正在等待该资源的线程
     * 关键字 native
     * 关键字 final
     */
    @HotSpotIntrinsicCandidate
    public final native void notifyAll();


    /**
     * 使当前线程一直等待,直到它被唤醒. 通常 被 notify 或者 被 interrupt
     * 关键字final
     * 调用 wait(0L)
     */
    public final void wait() throws InterruptedException {
        wait(0L);
    }


    /**
     * 使当前线程一直等待,直到它被唤醒. 通常 被 notify 或者 被 interrupt，或者超时
     * 关键字 final
     * 关键字 native
     */
    public final native void wait(long timeout) throws InterruptedException;

    /**
     * 使当前线程一直等待,直到它被唤醒. 通常 被 notify 或者 被 interrupt，或者超时
     * 关键字 final
     * 参数 nanos 是只纳秒， 很蛋疼的是只要 0 < nanos <= 999999, timeout ++ ， 也就是说根本没法精确到纳秒的级别 
     */
    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);
    }


    /**
     * 垃圾回收时调用
     */
    @Deprecated(since="9")
    protected void finalize() throws Throwable { }
}

2. 关于Object类： Object 类是所有类的父类，所有类，包括数组，都实现了该类的方法。

3. getClass() 方法

public final native Class<?> getClass();

　　a. 该方法通过 final 关键字修饰，不允许被重写

　　b. 该方法通过 native 关键字修饰，没有方法体，具体功能由 C/C++ 实现

　　c. 该方法返回一个 Class 类的实例。

　　　　The returned {@code Class} object is the object that is locked by {@code static synchronized} methods of the represented class. 这句话不太理解，好像是说返回的 Class类的实例是该对象所代表的类的静态同步方法（static synchronized methods）锁定的对象

　　d. 实际返回的类型是 Class<? extends |X|> ，|X| 是指描述该对象的类的擦除类型，英文水平有限。。直接看例子　　

Number n = 0;
Class<? extends Number> nClass = n.getClass();
System.out.println(nClass); // class java.lang.Integer

　　|X| 是指 Number 类

4. hashcode() 方法

public native int hashCode();

　　a. 该方法返回对象的哈希值

　　b. 关键字 native

　　c. hashcode 的通俗约定：

　　　　1）在同一个 java 程序实现中，对于同一个对象，只要对象用于 equals 方法比较的信息没被修改，不管何时调用 hashcode 方法都应该返回相同的值。

　　　　2）对于不同的实现，对同一个对象，hashcode 不必返回相同的值。

　　　　3）如果两个对象在使用 equals 方法比较时返回 true，则它们调用 hashcode 方法必须返回相同的值。

　　　　4）如果两个对象在使用 equals 方法时返回 false，则它们调用 hashcode 方法没有要求必须返回不同的整数值。但是在设计 hashcode 算法应该尽量返回不同的值（降低 hash 碰撞的概率）;

　　　　5) 事实上， Object 实现的 hashcode 方法也没有实现 4）情况的预期。

5. equals(Object obj) 方法

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

　　a. 该方法用于判断两个对象是否相等

　　b. 默认的实现等同于 == 操作符

　　c. equals 方法约定：

　　　　1）自反性：对任何一个非空对象 x， x.equals(x) 返回 true

　　　　2) 对称性：对于任意两个非空对象 x 和 y。如果 x.equals(y) 返回 true，那么 y.equals(x) 必须返回 true。

　　　　3）传递性，对于任何非空对象 x、y、z，如果 x.equals(y), y.equals(z) 都返回 true, 那么 x.equals(z) 必须返回 true。

　　　　4）一致性：对于任何非空对象x, y，只要在这个过程中 x，y没有做任何修改，x.equals(y) 返回的值必须相同。

　　　　5）对于任何非空对象 x， x.equals(null) 必须返回 false。

　　d. 重写 equals 方法的同时，必须重写 hashcode 方法以保证 equals 为 true 的两个对象调用 hashcode 方法必须相等。

6. clone() 方法

protected native Object clone() throws CloneNotSupportedException;

　　b. 返回该对象的一个副本（拷贝）

　　a. native 关键字

　　c. 对任意非空对象 x:

　　　　1) x.clone() != x 的结果是 true

　　　　2) x.clone().getClass() == x.getClass()的结果不一定为 true。很明显，因为这个方法定义返回的是 Object，理论上你可以自己在重写的时候返回任何类的实例，但是一般都会返回同一个类的实例。

　　　　3）x.clone().equals(x) 也没有要求必须返回 true

　　　　4）按照约定，返回的对象应该是调用 super.clone(), 如果一个类和它的所有父类都遵循这个约定（即都没有重写过 clone() 方法），x.clone().getClass() == x.getClass() 会返回 true.

　　　　5) 按照约定，返回的对象必须是独立于被 clone 对象的（不要返回它本身，不然就没有意义）。注意对 clone 对象里的可变引用字段的处理。

　　　　6）如果自定义类没有实现 Cloneable 接口，调用 clone 方法将抛出 CloneNotSupportedException

　　　　7）所有数组都实现了 Cloneable 接口并且可以调用 clone 方法。需要注意的是数组的 clone 方法的实现是一个 “浅拷贝”，不是”深拷贝“。其实本质上还是值传递和地址传递的区别。看以下测试代码

import java.util.Arrays;

public class CloneTest {

    public static void main(String[] args) throws CloneNotSupportedException {

        //测试数组 clone
        int[] nums = {0, 1, 2, 3, 4, 5};
        int[] cnums = nums.clone();
        System.out.println(Arrays.toString(nums));  //[0, 1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(cnums)); //[0, 1, 2, 3, 4, 5]

        nums[4] = 8;
        System.out.println(Arrays.toString(nums));    //[0, 1, 2, 3, 8, 5]
        System.out.println(Arrays.toString(cnums));  //[0, 1, 2, 3, 4, 5]


        People p1 = new People("a", 0);
        People p2 = new People("b", 1);
        People p3 = new People("c", 2);
        People[] ps = {p1, p2, p3};
        People[] cps = ps.clone();
        print(ps);    //People{name=‘a‘, age=0} People{name=‘b‘, age=1} People{name=‘c‘, age=2}
        print(cps);   //People{name=‘a‘, age=0} People{name=‘b‘, age=1} People{name=‘c‘, age=2}
        
        p1.setAge(100);
        print(ps);    //People{name=‘a‘, age=100} People{name=‘b‘, age=1} People{name=‘c‘, age=2}
        print(cps);   //People{name=‘a‘, age=100} People{name=‘b‘, age=1} People{name=‘c‘, age=2}



    }

    static void print(Object[] objects) {
        for (Object obj : objects) {
            System.out.print(obj +  " ");
        }
        System.out.println();
    }
}


class People{

    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "People{" +
                "name=‘" + name + ‘‘‘ +
                ", age=" + age +
                ‘}‘;
    }

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

    protected void say(){
        System.out.println("!!!");
    }
}