欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-11-30 15:27:47
Object是所有类的根类,是所有类的老祖宗,我们有必要对Object类里的方法进行解析,下面来解析一下Object类的几个常用方法。关于toString()方法:源代码:public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }源代码上的toString()方法的默认实现是:返回一个对象的字符串形式表示:类名@对象堆内存地址经哈希...

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