JavaSE笔记10：Object类中的部分方法

最新推荐文章于 2024-10-22 22:11:31 发布

原创最新推荐文章于 2024-10-22 22:11:31 发布 · 152 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #编程语言 #hashcode #object

java 同时被 2 个专栏收录

28 篇文章

订阅专栏

JavaSE

28 篇文章

订阅专栏

本文深入讲解Java中的toString和equals方法，探讨其默认行为与重写的重要性，并介绍hashCode和finalize方法的作用。

Object类中的部分方法

toString()方法

1.源码

public String toString(){
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
//源代码上toString()方法的默认实现是：类名 @ 对象的内存地址转换为16进制的形式

2.设计出该方法目的/作用

toString()方法的设计目的是：通过调用这个方法可以将一个“java对象”转换成“字符串表示形式”

3.注意

建议所有的子类都去重写toString()方法
toString()方法应该是简洁的、详实的、易阅读的
IDEA可以直接快捷键生成：ALT + INS键，在弹出的窗口中选择即可

例子：

package se2.obj;

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

        MyTime t1 = new MyTime(1970,1,1);
        String s1 = t1.toString();
        //MyTime类重写toString()方法之前
        //结果为：se2.obj.MyTime@154617c
        //System.out.println(s1);

        //MyTime类重写toString()方法之后
        //注意：输出引用的时候，会自动调用该引用的toString()方法
        //System.out.println(s1.toString());
        System.out.println(s1);//1970年1月1日

    }
}
class MyTime{
    int year;
    int month;
    int day;

    public MyTime(){}
    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    //重写toString()方法,越简洁越好，可读性越强越好
    public String toString(){
        return this.year + "年" + this.month + "月" + this.day + "日";
    }
}

equals()方法

1.源码

public boolean equals(Object obj){
    return (this == obj);
}
//以上这个方法是Object类的默认实现

2.设计equals方法的目的

equals方法是判断两个对象是否相等的。

3.注意

以后编程的过程中，都要通过equals方法来判断两个对象是否相等。
判断两个java对象是否相等不能使用“”，因为“”比较的是对象的内存地址。
在Object类中的equals方法当中，默认采用的是“”判断两个java对象是否相等，而“”判断的是两个java对象的内存地址，所以需要子类重写equals方法。
IDEA可以直接快捷键生成：ALT + INS键，在弹出的窗口中选择即可

例子：

package se2.obj;

public class EqualsTest01 {
    public static void main(String[] args) {
        //判断两个基本数据类型的数据是否相等直接使用“==”就行
        int a = 100;
        int b = 100;
        System.out.println(a == b);//true(相等)

        //判断两个java对象是否相等，怎么办？能直接使用“==”吗？
        //创建一个日期对象是：2008年8月8日
        MyTime2 t1 = new MyTime2(2008,8,8);//假设这里t1对象的内存地址是：0x1234
        //创建一个新的日期对象，日期也是：2008年8月8日
        MyTime2 t2 = new MyTime2(2008,8,8);//假设这里t2对象的内存地址是：0x3698
        //测试以下，比较两个对象是否相等，能不能使用“==”？
        //这里的“==”判断的是：t1中保存的对象内存地址和t2中保存的对象内存地址是否相等！！！
        System.out.println(t1 == t2);//false(不相等)

        //重写equals之前(比较的是内存地址)
        //boolean flag = t1.equals(t2);
        //System.out.println(flag);//false

        //重写equals之后(比较的是内容)
        boolean flag2 = t1.equals(t2);
        System.out.println(flag2);//true

        //再创建一个新的日期
        MyTime2 t3 = new MyTime2(2008,8,9);
        System.out.println(t1.equals(t3));//false

        MyTime2 t4 = null;
        System.out.println(t1.equals(t4));//false
    }
}
class MyTime2{
    int year;
    int month;
    int day;

    public MyTime2(){}
    public MyTime2(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    //默认的equals方法
    /*
    public boolean equals(Object obj){
        return (this == obj);
    }
    */
    //重写equals方法
    public boolean equals(Object obj){
        //如果obj为空直接返回false或者obj不是一个MyTime2，没必要比较，直接返回false（效率）
        if (obj == null || !(obj instanceof MyTime2)) return false;
        //如果this和obj保存的内存地址相同，没必要比较了，直接返回true
        //内存地址相同的时候指向的堆内存的对象肯定是同一个
        //程序能够执行到这说明obj不是null，是MyTime2类型
        if (this == obj) return true;
        MyTime2 t = (MyTime2)obj;
        return this.year == t.year && this.month == t.month && this.day == t.day;
    }
}

探讨String类有没有重写toString方法和equals方法

package se2.obj;
/*
java语言当中的字符串String有没有重写toString方法，有没有重写equals方法？
 */
public class ToStringAndEqualsTest {
    public static void main(String[] args) {
        //大部分情况下，采用这样的方式创建字符串对象
        String s1 = "hello";
        String s2 = "abc";
        //实际上String也是一个类，不属于基本数据类型
        //既然String是一个类，那么一定存在构造方法
        String s3 = new String("Test1");
        String s4 = new String("Test1");
        //new 两次，两个对象内存地址，s3保存的内存地址和s4保存的内存地址不同
        System.out.println(s3 == s4);//false
        //比较两个字符串不能使用双等号，必须调用equals方法
        //String类已经重写了equals方法了
        System.out.println(s3.equals(s4));//true

        //String类有没有重写toString类呢？
        String x = new String("阿波");
        //如果没有重写，输出的结果为：java.lang.String十六进制的地址
        //经过测试，String类已经重写了toString方法
        System.out.println(x.toString());//阿波
        System.out.println(x);//阿波
        //可以不用加上.toString()，效果一样
    }
}

总结：

String类已经重写了equals方法，比较两个字符串不能使用“==”，必须使用equals
String类已经重写了toString方法
java中什么类型的数据可以使用“==”判断？

java中基本数据类型比较是否相等，使用“==”
java中什么类型的数据需要使用equals判断

java中所有的引用数据类型统一使用equals方法来判断是否相等

重写Object类的equals

package se2.obj;

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

        student s1 = new student(111,"波波小学");
        student s2 = new student(111,"波波小学");
        //new的方式
        student s3 = new student(111,new String("波波小学"));
        student s4 = new student(111,new String("波波小学"));

        System.out.println(s1 == s2);//false
        System.out.println(s1.equals(s2));//true

        System.out.println(s3 == s4);//false
        System.out.println(s3.equals(s4));//true
    }
}
class student{
    //学号
    int no;//基本数据类型，比较时使用“==”
    //所在学校
    String school;//引用数据类型，比较时使用equals
    //构造方法
    public student() {}
    public student(int no, String school) {
        this.no = no;
        this.school = school;
    }
    //重写toString方法
    public String toString(){
        return "学号" + no + "，所在学校名称" + school;
    }
    //重写equals方法
    //需求：当一个学生的学号相等，并且学校相同时，表示同一个学生
    //equals方法编写的模式都是固定的，架子差不多
    public boolean equals(Object obj){
        if(obj == null || !(obj instanceof student)) return false;
        if (this == obj) return true;
        student s = (student)obj;
        //if (this.no == s.no && 字符串对象.equals(另一个字符串对象))
        return this.no == s.no && this.school.equals(s.school);
        //字符串不可以用双等号比较，用上面new的方式创建对象即使内容相同也会一直显示false
        //return this.no == s.no && this.school == s.school;
    }
}

package se2.obj;

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

        User u1 = new User("阿波",new Address("广州","XX街","1111"));
        User u2 = new User("阿波",new Address("广州","XX街","1111"));
        
        System.out.println(u1.equals(u2));//false
    }
}
class User{
    //用户名
    String name;
    //用户住址,Address是自己写的类
    Address addr;

    public User() {}
    public User(String name, Address addr) {
        this.name = name;
        this.addr = addr;
    }
    //重写equals方法
    //规则：当一个用户的用户名和家庭住址都相同，表示同一个用户
    //这个equals判断的是User对象和User对象是否相等
    public boolean equals(Object obj){
        //用户名和用户名相同，住址和住址相同的时候，认定是同一个用户
        if (obj == null || !(obj instanceof User)) return false;
        if (this == obj) return true;
        User u = (User)obj;
        if (this.name.equals(u.name) && this.addr.equals(u.addr)){
            return true;
        }
        return false;
    }
}
//class Address extends Object
//由于默认继承了Object，所有equals方法也继承了
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方法
    //这里的equals方法判断的是：Address对象和Address对象是否相等
    //Address中的equals方法没有重写的时候，比较的是对象的内存地址
}

equals深层次剖析

package se2.obj;

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

        User u1 = new User("阿波",new Address("广州","XX街","1111"));
        User u2 = new User("阿波",new Address("广州","XX街","1111"));
        System.out.println(u1.equals(u2));//false
    }
}
class User{
    //用户名
    String name;
    //用户住址,Address是自己写的类
    Address addr;

    public User() {}
    public User(String name, Address addr) {
        this.name = name;
        this.addr = addr;
    }
    //重写equals方法
    //规则：当一个用户的用户名和家庭住址都相同，表示同一个用户
    //这个equals判断的是User对象和User对象是否相等
    public boolean equals(Object obj){
        //用户名和用户名相同，住址和住址相同的时候，认定是同一个用户
        if (obj == null || !(obj instanceof User)) return false;
        if (this == obj) return true;
        User u = (User)obj;
        if (this.name.equals(u.name) && this.addr.equals(u.addr)){
            return true;
        }
        return false;
    }
}
//class Address extends Object
//由于默认继承了Object，所有equals方法也继承了
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方法
    //这里的equals方法判断的是：Address对象和Address对象是否相等
    //Address中的equals方法没有重写的时候，比较的是对象的内存地址
}

重写Address类的equals方法后如下：

package se2.obj;

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

        User u1 = new User("阿波",new Address("广州","XX街","1111"));
        User u2 = new User("阿波",new Address("广州","XX街","1111"));
        System.out.println(u1.equals(u2));//true

        User u3 = new User("阿波",new Address("广州","YY街","1112"));
        System.out.println(u1.equals(u3));//false
    }
}
class User{
    //用户名
    String name;
    //用户住址,Address是自己写的类
    Address addr;

    public User() {}
    public User(String name, Address addr) {
        this.name = name;
        this.addr = addr;
    }
    //重写equals方法
    //规则：当一个用户的用户名和家庭住址都相同，表示同一个用户
    //这个equals判断的是User对象和User对象是否相等
    public boolean equals(Object obj){
        //用户名和用户名相同，住址和住址相同的时候，认定是同一个用户
        if (obj == null || !(obj instanceof User)) return false;
        if (this == obj) return true;
        User u = (User)obj;
        if (this.name.equals(u.name) && this.addr.equals(u.addr)){
            return true;
        }
        return false;
    }
}
//class Address extends Object
//由于默认继承了Object，所有equals方法也继承了
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(obj == null || !(obj instanceof Address)) return false;
        if (this == obj) return true;
        //怎么算家庭住址相同呢？
        //城市相同、街道相同、邮编相同，表示相同
        Address a = (Address)obj;
        if (this.city.equals(a.city)
                && this.street.equals(a.street)
                && this.zipcode.equals(a.zipcode)){
            return true;
        }
        return false;
    }
}

总结toString和equals方法

1.toString()方法

以后所有类的toString方法是需要重写的
重写规则：越简单越明了就好

//System.out.println(引用);这里会自动调用"引用"的toString()方法
String 类是SUN写的，toString方法已经重写了

2.equals()方法

以后所有类的equals方法也需要重写，因为Object中的equals方法比较的是两个对象的内存地址，我们应该比较内容，所以需要重写。
重写规则：自己定，主要看是什么和什么相等时表示两个对象相等
基本数据类型比较时用：==
对象和对象比较：调用equals方法
String类是sun编写的，所以String类的equals方法重写了
以后判断两个字符串是否相等，最好不要使用==，要调用字符串对象的equals方法
重写equals方法的时候要彻底（参考equals深层次剖析的两个例子）

finalize()方法（了解即可）

1.源码

//这个方法是protected修饰的，没有方法体，在Object类中这个方法的源代码如下:
protected void finalize() throws Throwable{ }
//这个方法不需要程序员手动调用，JVM的垃圾回收器负责调用这个方法

finalize()方法的执行时机：

当一个java对象即将被垃圾回收器回收的时候，垃圾回收器负责调用finalize()方法。

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

2.注意

java中的垃圾回收器不是轻易启动的，垃圾太少，或者时间没到，种种条件下，有可能启动，也有可能不启动。
有一段代码可以建议垃圾回收器启动：System.gc();

package se2.obj;

public class FinalizeTest01 {
    public static void main(String[] args) {
        //多造点垃圾
        for (int i = 0; i < 1000; i++) {
            Person p = new Person();
            p = null;
            //有一段代码可以建议垃圾回收器启动
            if (i % 2 == 0){
                System.gc();//建议启动垃圾回收器（只是建议，可能不启动，也可能启动）
            }
        }
    }
}
class Person{
    //重写finalize方法
    //Person类型的对象被垃圾回收器回收的时候，垃圾回收器负责调用：p.finalize();
    protected void finalize() throws Throwable {
        //this代表当前对象
        System.out.println(this + "即将被销毁！");
    }
}
/*
运行结果：
    se2.obj.Person@1f18626即将被销毁！
    se2.obj.Person@1366aa8即将被销毁！
    se2.obj.Person@109ed56即将被销毁！
    se2.obj.Person@b6093即将被销毁！
    se2.obj.Person@1d01d02即将被销毁！
    ...
 */

hashCode()方法（了解）

1.源码

public native int hashCode();
//这个方法不是抽象方法，带有native关键字，底层调用c++程序

hashCode方法返回的是哈希码：

实际上就是一个Java对象的内存地址，经过哈希算法，得出的一个值

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

2.例子：

package se2.obj;

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

        Object o = new Object();
        int hashCodeValue = o.hashCode();
        //对象内存地址经过哈希算法转换的一个数字，可以等同看做内存地址。
        System.out.println(hashCodeValue);//22307196

        MyClass mc = new MyClass();
        int hashCodeValue2 = mc.hashCode();
        System.out.println(hashCodeValue2);//10568834

        MyClass mc2 = new MyClass();
        System.out.println(mc2.hashCode());//21029277
    }
}
class MyClass{}