Java中Object对象的常用方法解析

Object是所有类的根类，是所有类的老祖宗，我们有必要对Object类里的方法进行解析，下面来解析一下Object类的几个常用方法：toString，equals，finalize，clone和hashCode方法。

1.关于toString()方法：

源代码：

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

源代码上的toString()方法的默认实现是：
返回一个对象的字符串形式表示：类名@对象堆内存地址经哈希算法处理得到的16进制值。

SUN公司设计toString()方法的目的是什么？
目的：通过调用这个方法将一个对象转换成字符串形式，以便简洁，详实，易阅读。

其实SUN公司开发java语言的时候，建议所有的子类都去重写toString()方法。

测试代码：

public class Test {
    public static void main(String[] args) {
        MyDate m1 = new MyDate(2020, 1, 1);
        System.out.println(m1);  //输出：2020年1月1日
    }
}

//定义一个日期类，默认继承Object
class MyDate {
    //属性：年月日
    public int year;
    public int month;
    public int day;

    //构造方法
    public MyDate() {

    }
    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    //重写Object里的toString()方法
    public String toString() {
        return year + "年" + month + "月" + day + "日";
    }
}

---

2.关于equals()方法：

源代码：

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

上面方法使用了“==”来判断两个对象是否相同，判断的是两个对象的堆内存地址是否相同。

我们发现Object给的equals()方法根本不够子类使用，所以SUN公司建议子类去重写equals()方法。

两个基本类型数据比较用“==”，引用数据类型比较用equals()方法。

测试代码：

import java.util.Objects;

public class Test02 {
    public static void main(String[] args) {
        //实例化两个对象，p1和p2，他们的属性值相同
        Person p1 = new Person("110001", "张三", 20);  //p1保存的是“张三”这个对象的堆内存地址，假设是：0x1234
        Person p2 = new Person("110001", "张三", 20);  //p2保存的是“李四”这个对象的堆内存地址，假设是：0x5678
        Person p3 = p1;  //p3保存的是p1的值，也是：0x1234
        Person p4 = null;  //p4赋null值

        //没有重写equals()方法之前：
        /*System.out.println(p1.equals(p2));  //输出：false
        System.out.println(p1.equals(p3));  //输出：true
        System.out.println(p1.equals(p4));  //输出：false
        System.out.println(p4.equals(p1));  //运行报错：空指针异常*/

        //重写equals()方法之后：
        /*System.out.println(p1.equals(p2));  //输出true
        System.out.println(p1.equals(p3));  //输出true
        System.out.println(p1.equals(p4));  //输出：false*/

        //测试String已经重写的equals()方法
        String str1 = "hello";
        String str2 = new String("hello");
        String str3 = "hello";
        System.out.println(str1 == str2); //输出：false
        System.out.println(str1 == str3); //输出：true
        System.out.println(str2 == str3); //输出：false

        System.out.println(str1.equals(str2));  //输出：true
        System.out.println(str1.equals(str3));  //输出：true
        System.out.println(str2.equals(str3));  //输出：true
        //所以说：引用类型比较是否相同，用equals最稳定

        //测试null与null是否相同
        String s1 = null;
        String s2 = null;
        Person p5 = null;
        System.out.println(Objects.equals(s1, s2));  //输出true，两个引用类型都为空，它们相同
        System.out.println(Objects.equals(s1, p5));  //输出true，两个引用类型都为空，它们相同
        System.out.println(null == null);  //输出：true
        //所以说null与null比较恒等于true，属于没有意义的比较
    }
}

//定义一个Person类，默认继承Object
class Person {
    public String idCard;
    public String name;
    public int age;

    public Person() {

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

    //重写父类Object的equals()方法
    //该怎么重写由你自己定义，你认为两个对象怎么样才算相同？你就怎么重写
    //假设两个对象的属性相同，定义成两个对象相同，好的，我们来重写
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || this.getClass() != obj.getClass()) {
            return  false;
        }
        Person p = (Person)obj;  //String类已经重写了equals()方法
        return this.age == p.age && this.idCard.equals(p.idCard) && this.name.equals(p.name);
    }
}

如果一个类里面的属性也是一个类时，怎么比较相同？
答：除了当前类重写Object的equals()方法，要求属性类也重写了Object的equals()方法。

public class Test03 {
    public static void main(String[] args) {
        User u1 = new User("张三", new Address("广东省", "深圳市", "龙华区0001"));
        User u2 = new User("张三", new Address("广东省", "深圳市", "龙华区0001"));
        System.out.println(u1.equals(u2));  //输出：true
    }
}

//用户：User
class User {
    String name;
    Address address;

    public User() {

    }
    public User(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    //重写Object的equals()方法
    //重写规则：自己定义，这里认为名字一样且住址一样的用户是同一个用户
    public boolean equals(Object obj) {
        if (this == obj)    return true;
        if (obj == null || !(obj instanceof User))  return false;
        User u = (User)obj;
        //下面一行代码要求Address类也要重写equals()方法
        return this.name.equals(u.name) && this.address.equals(u.address);
    }
}

//住址：Address
class Address {
    String city;
    String street;
    String zipCode;

    public Address() {

    }
    public Address(String city, String street, String zipCode) {
        this.city = city;
        this.street = street;
        this.zipCode = zipCode;
    }

    //重写equals()方法
    public boolean equals(Object obj) {
        if (this == obj)    return true;
        if (obj == null || !(obj instanceof Address))   return false;
        Address a = (Address)obj;
        //下面一行代码要求String类重写equals()方法，显然String类已经重写了equals()方法
        return this.city.equals(a.city) && this.street.equals(a.street) && this.zipCode.equals(a.zipCode);
    }
}

注意：equals()方法重写要彻底。

---

3.关于finalize()方法：

源代码：

protected void finalize throws Throwable { 

}

finalize()方法只有一个空方法体，里面没有代码，而且这个方法是protected修饰的。

这个方法不需要程序员手动调用，JVM的垃圾回收器（也叫GC）负责调用这个方法。

finalize()方法执行时机：
当一个java对象即将被垃圾回收器回收的时候，在对象销毁之前，垃圾回收器先调用这个finalize()方法。

finalize()方法实际上是SUN公司为java程序员准备的一个时机，垃圾销毁时机。如果你想在对象销毁时机执行一段代码的话，这段代码要写在重写的finalize()方法当中。

有点类似静态代码块的作用，静态代码块的语法及作用：
附上：静态代码块知识的详解
语法：

static {
	//代码块
}

作用：静态代码块在类加载时刻执行，并且只执行一次。这是SUN公司为我们准备的类加载时机。

finalize()方法同样也是SUN公司为我们提供的一个对象的垃圾回收时机。

finalize()方法只能在java8版本之前使用，java9就把这个方法给遗弃了，但还是可以使用的。

提示：JVM的垃圾回收器（GC）并不是每时每刻都会启动的，当垃圾太少，时间没到时，它不会启动，受各种条件影响的。

有一句代码可以建议垃圾回收器启动，但建议归建议，要不要启动还是看垃圾回收器自己的脸色。
建议启动垃圾回收器的代码：System.gc();

可以这样理解，finalize()方法是一个对象被销毁之前的遗言。

测试代码：

public class Test04 {

    public static void main(String[] args) {
        //垃圾太少时，垃圾回收器不会启动，我们测试产生一个亿的垃圾对象（哈哈，看你GC启不启动）
        /*for (int i = 0; i < 100000000; i++) {
            RubbishTest r = new RubbishTest();
            //将r指向的对象变成垃圾
            r = null;
        }*/

        //垃圾太少时，用System.gc()建议垃圾回收器启动，建议归建议，启动看脸色
        for (int i = 0; i < 100; i++) {
            RubbishTest r = new RubbishTest();
            //将r指向的对象变成垃圾
            r = null;
            //建议GC启动
            System.gc();
        }
    }
}

//定义一个类
class RubbishTest {
    //重写finalize()方法
    protected void finalize() throws Throwable {
        System.out.println(this + "即将被销毁");
    }
}

---

4.关于clone()方法。

源代码：

protected native Object clone() throws CloneNotSupportedException;

从源代码可知，根类Object的clone方法是用protected关键字修饰的，SUN公司这样做是为避免我们创建的每一个类都默认具有克隆能力。 且没有方法体，而是用native修饰的，底层调用C++动态链接库实现的。

一个类要想实现克隆功能，就得先实现Cloneable接口，再重写clone()方法，例如：

class A implements Cloneable {
    //重写clone()方法：源码粘贴过来，去掉native关键字，返回类型Object变为A，写上方法体。
    protected A clone() throws CloneNotSupportedException {
        return (A)super.clone();
    }
}

clone()方法返回的是一个对象的副本，副本对象的地址发生变化，内容却一样，例如：

A a1 = new A();
A a2 = a1.clone();  //a2对象的内容跟a1对象的内容一样，但a2保存的地址跟a1保存的地址不一样。

浅克隆与深克隆的概念：
浅克隆：只复制引用对象的地址，对象只有一份，引用却有两份。例如：

A a1 = new A();   
A a2 = a1;  //称a2是a1的浅克隆。a1，a2指向同一对象

深克隆：重新创建一份对象，对象地址不一样，内容一样。对象两份，引用两份。例如：

A a1 = new A();  
A a2 = a1.clone();  //称a2是a1的深克隆。a1，a2是两个不同的对象，只是两个对象里面的数据相同。

测试代码：

public class Test05 {
    public static void main(String[] args) {

        Cat c1 = new Cat(5);
        Cat c2 = c1;  //c2是c1的浅克隆
        System.out.println(c1.toString() + "---" + c1.i);  //输出：Cat@1111---5
        System.out.println(c2.toString() + "---" + c2.i);  //输出：Cat@1111---5

        //克隆可能会产生异常，需要try catch语句
        try {
            Cat c3 = c1.clone();  //c3是c1的深克隆
            Cat c4 = c1.clone();  //c4是c1的深克隆
            System.out.println(c3.toString() + "---" + c3.i);  //输出：Cat@2222---5
            System.out.println(c4.toString() + "---" + c4.i);  //输出：Cat@3333---5
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }
}

//一个类要想实现克隆功能，就得实现Cloneable接口
class Cat  implements Cloneable {
    int i;

    //构造方法
    public Cat() {

    }
    public Cat(int i) {
        this.i = i;
    }

    //先将源代码赋值粘贴过来:
    //protected native Object clone() throws CloneNotSupportedException;
    //把native去掉，native表示底层调用C++的动态链接库，这里我们不需要，让Object自己去调用
    //返回类型改成自己同类类型，不要担心转型异常，不能转型会抛出克隆异常
    protected Cat clone() throws CloneNotSupportedException {
        return (Cat)super.clone();  //调用父类的clone()方法，再强制转换成Cat型
    }
}

---

5.关于hashCode()方法：

源代码：

public native int hashCode();

公开的，带有native关键字，底层调用C++程序，返回值为int型数字。

hashCode()方法返回的是哈希码：实际上就是一个java对象的内存地址，经过哈希算法，得出的一个值。

所以hashCode()方法的执行结果可以等同看做一个java对象的内存地址。

跟toString()方法类似，toString()方法返回的是：类名@内存地址经哈希算法转换成的16进制数。

hashCod()返回值是一个对象内存地址哈希处理后得到的10进制，toString()方法返回值中的是16进制

关于hashCode()方法的重写，等学了List和Set再写。

本文地址：https://blog.csdn.net/pipizhen_/article/details/107236375