@TryLoveCatch 2022-04-14T16:47:18.000000Z 字数 5998 阅读 583

Java知识体系之Object类

Java知识体系

getClass()

public final native Class<?> getClass();

这是一个 final 类型的native方法，也就是说这个方法不能被子类重写，同时它的实现并不是通过Java语言实现的，而是用其他语言（C/C++）实现的，一般主要用在反射里面。
由于设计到JNI，所以这个方法是有一定耗时的是，使用的时候需要注意，还就是，toString()就使用了该方法。

toString()

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

返回一个 String 对象，一般子类都有覆盖。默认返回格式如下：对象的 class 名称 + @ + hashCode 的十六进制字符串。

调用到的方法：

getClass()
hashCode()

equals() & hashcode()

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

hashcode()方法主要用于获取对象的散列值。Object 中该方法默认返回的是对象的堆内存地址。
equals()方法用于比较两个对象，在 Object 中直接使用的是 == ，也就是比较两个对象的地址是否相同。子类一般都要重写这个方法。

equals()和hashcode()关系

考虑一下HashMap，其实就是先判断hashCode再判断equals。

如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。
如果两个对象不equals，他们的hashcode有可能相等。
如果两个对象hashcode相等，他们不一定equals。
如果两个对象hashcode不相等，他们一定不equals。

equals()原则

自反性（Reflexive）
一个对象与自身相等，即 x=x。对任何非空对象 x， x.equals(x) 必定为 true。
对称性（Symmetric）
对象之间的等价关系是可交换的，即 a=b⇔b=a。对任何非空对象 x、y， x.equals(y) 为 true，当且仅当 y.equals(x) 为 true。
传递性（Transitive）
(a=b)∧(b=c)⇒(a=c)。对任何非空对象 x、y、z，若 x.equals(y) 为 true 且 y.equals(z) 为 true，则 x.equals(z) 为 true。

除了遵循这三原则之外，还要遵循：

一致性（Consistent）
对任何非空对象 x、y，只要所比较的信息未变，则连续调用 x.equals(y) 总是得到一致的结果。这要求了 equals 所依赖的值必须是可靠的。
对任何非空对象 x， x.equals(null) 必定为 false。

equals() & ==

==
- 对于基本数据类型的变量，是直接比较其存储的 “值”是否相等；
- 对于引用数据类型的变量，是比较对象的内存地址。
equals()
- 如果没有重写，Object里面默认也是比较对象的内存地址。
- 如果重写了，则走自定义的逻辑。

hashCode如何重写

关于相应的哈希算法，一个简单的算法如下:

永远不要让哈希算法返回一个常值，这时哈希表将退化成链表，查找时间复杂度也从 O(1) 退化到 O(N)
如果参数是boolean型，计算(f ? 1 : 0)
如果参数是byte, char, short或者int型，计算(int) f
如果参数是long型，计算(int) (f ^ (f >>> 32)) 高32位保持不变，低32位和高32位做异或
如果参数是float型，计算Float.floatToIntBits(f)
如果参数是double型，计算Double.doubleToLongBits(f)得到long类型的值，再根据公式计算出相应的hash值
如果参数是Object型，那么应计算其有用的成员变量的hash值，并按照下面的公式计算最终的hash值
如果参数是个数组，那么把数组中的每个值都当做单独的值，分别按照上面的方法单独计算hash值，最后按照下面的公式计算最终的hash值

组合公式：result = 31 * result + c

比如，String 类的 hashCode 方法如下（JDK 1.8）：

public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

class Baz {
    private int id;
    private String name;
    private double weight;
    private float height;
    private String note;
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Baz baz = (Baz) o;
        if (id != baz.id) return false;
        if (Double.compare(baz.weight, weight) != 0) return false;
        if (Float.compare(baz.height, height) != 0) return false;
        if (name != null ? !name.equals(baz.name) : baz.name != null) return false;
        return !(note != null ? !note.equals(baz.note) : baz.note != null);
    }
    @Override
    public int hashCode() {
        int result;
        long temp;
        result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        temp = Double.doubleToLongBits(weight);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        result = 31 * result + (height != +0.0f ? Float.floatToIntBits(height) : 0);
        result = 31 * result + (note != null ? note.hashCode() : 0);
        return result;
    }
}

clone()

protected native Object clone() throws CloneNotSupportedException;

clone()方法默认实现对象的浅拷贝
clone()方法是保护方法，不对外提供
只有实现了 Cloneable 接口才可以调用该方法，否则抛出 CloneNotSupportedException 异常。

为什么需要clone

目的是想要两个相同的对象,重新new一个还得自己重新赋值,太麻烦

深拷贝&浅拷贝

浅拷贝
- 基本数据类型，直接复制值
- 引用类型，直接复制对象内存地址
深拷贝
- 基本数据类型，直接复制值
- 引用类型，重新申请内存空间，并递归复制原有对象的所有内容

举个例子，一个男孩拥有一台电脑

浅拷贝,成了两个男孩,但他们共享一台电脑
深拷贝,成了两个男孩,他们拥有各自的电脑

浅拷贝实现

需要拷贝的对象（Student）实现Cloneable接口

重写clone()方法

访问修饰符修改为public

通过super.clone()调用Object类中的原clone方法。

public class Student implements Cloneable {
    private String name;
    private Bag bag;
    public Student(String name,Bag bag) {
        this.name = name;
        this.bag = bag;
    }
    @Override
    public Student clone(){
        Student stu = null;
        try{
            stu = (Student)super.clone();
        } catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return stu;
    }
}
//背包类
public class Bag {
    private String name;
    public void setName(String name) {
        this.name = name;
    }
}

深拷贝实现

多层实现Cloneable类

需要拷贝的对象（Student）以及其所有的对象成员变量（Bag）实现Cloneable接口

重写clone()方法

访问修饰符修改为public

通过super.clone()调用Object类中的原clone方法。

对于成员变量，都调用其重写的clone()方法

public class Student implements Cloneable {
    private String name;
    private Bag bag;
    public Student(String name,Bag bag) {
        this.name = name;
        this.bag = bag;
    }
    // 这里不一样！！！！！
    @Override
    public Student clone(){
        Student stu = null;
        try{
            //浅克隆
            stu = (Student)super.clone();
        } catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        //深克隆
        stu.bag = (Bag)bag.clone();
        return stu;
    }
}
//背包类
public class Bag {
    private String name;
    public Bag(String name) {
        this.name = name;
    }
    // 这里不一样！！！！！
    @Override
    public Bag clone(){
        Bag bag= null;
        try{
            bag= (Bag )super.clone();
        } catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return bag;
    }
}

可用性比较差，若Bag类中还含有成员引用,则又需要再让它实现Cloneable接口重写clone方法,这样代码会显得很臃肿,且繁琐。
每次新增加一个对象类型的成员变量，都需要重新更改clone()方法

利用序列化和反序列化

需要拷贝的对象（Student）实现Serializable接口

在需要拷贝的对象（Student）里面增加新方法，例如myClone()

通过ObjectOutputStream和ObjectInputStream序列化和反序列化获取到新的对象

// 这里不一样！！！！！
public class Student implements Serializable {
    private String name;
    private Bag bag;
    public Student(String name,Bag bag) {
        this.name = name;
        this.bag = bag;
    }
// 这里不一样！！！！！
    public Student myClone(){
        Student stu = null;
        try {
            //将对象序列化到流里
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(os);
            oos.writeObject(this);
            //将流反序列化成对象
            ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(is);
            stu = (Student) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return stu;
    }
}
// 这里不一样！！！！！
public class Bag implements Serializable {
    private String name;
    public Bag(String name) {
        this.name = name;
    }
}

如果某个属性被transient修饰，那么该属性就无法被拷贝了。

finalize()

protected void finalize() throws Throwable { }

finalize()方法是保护方法，主要用于在 GC 的时候再次被调用，如果我们实现了这个方法，对象可能在这个方法中再次复活，从而避免被 GC 回收。

finalize & final & finally

final可以用来修饰类、方法、变量
- final修饰的class代表不可以继承扩展
- final的变量是不可以修改的
- final的方法也是不可以重写的（override）。
finally则是Java保证重点代码一定要被执行的一种机制。我们可以使用try-finally或者try-catch-finally来进行类似关闭JDBC连接、保证unlock锁等动作。
finalize是基础类java.lang.Object的一个方法，它的设计目的是保证对象在被垃圾收集前完成特定资源的回收。finalize机制现在已经不推荐使用，并且在JDK 9开始被标记为deprecated。

notify & notifyAll & wait

public final native void notify();
public final native void notifyAll();
public final native void wait(long timeout) throws InterruptedException;
public final void wait() throws InterruptedException {
    wait(0);
}

都是final方法，不能被子类重写。

notify,用于唤醒在该对象上等待的某个线程。
notifyAll,用于唤醒在该对象上等待的所有线程。
wait() 方法一直等待，直到获得锁或者被中断
wait(long timeout) ,设定一个超时间隔，如果在规定时间内没有获得锁就返回。

参考

https://www.sczyh30.com/posts/Java/java-hashcode-equal/
https://zhuanlan.zhihu.com/p/41880899