非零基础自学Java (老师：韩顺平) 第8章 面向对象编程(中级部分) 8.12 Object类详解

非零基础自学Java (老师：韩顺平)

✈【【零基础 快速学Java】韩顺平 零基础30天学会Java】

第8章 面向对象编程(中级部分)

8.12 Object类详解

8.12.1 equals方法

【 == 和 equals的对比】

• == 是一个比较运算符
• == 既可以判断基本类型，又可以判断引用类型
• == 如果判断基本类型，判断的是值是否相等。
• == 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
• equals 是 Object类中的方法，只能判断引用类型
• equals 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。

举个栗子

package com.dingjiaxiong.object_;

import com.dingjiaxiong.extend_.improve_.Pupil;

/**
 * ClassName: Equals01
 * date: 2022/9/3 13:08
 *
 * @author DingJiaxiong
 */

public class Equals01 {
    public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;

        System.out.println(a == c); //true
        System.out.println(b == c); //true

        B oObj = a;
        System.out.println(oObj == c); //true

        int num1 = 10;
        double num2 = 10.0;
        System.out.println(num1 == num2); // 基本数据类型，判断值是否相等
    }
}

class B{}
class A extends B{

}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

运行结果

这是 == 。

查看equals源码

光标放在方法上，Ctrl + b

最原始的equals方法

默认比较是否是同一个对象(地址是否相等)。

【而String或者Integer的equals方法都被重写为判断两个值是否相等】

举个栗子

Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);

System.out.println(integer1 == integer2);
System.out.println(integer1.equals(integer2));
1
2
3
4
5

integer1和integer2都是对象，当使用 == 进行比较时，判断是否是同一个对象，很明显不是

使用equals进行比较时，因为Integer类中重写了equals方法，变为了判断值是否相等

运行结果

String 类同理

8.12.2 自己如何重写equals方法

判断两个 Person 对象的内容是否相等，如果两个 Person 对象的各个属性值都一样，则返回 true，反之 false

package com.dingjiaxiong.object_;

/**
 * ClassName: EqualsExercise01
 * date: 2022/9/3 13:42
 *
 * @author DingJiaxiong
 */

public class EqualsExercise01 {
    public static void main(String[] args) {
        Person person1 = new Person("jack",10,'男');
        Person person2 = new Person("jack",10,'男');

        System.out.println(person1.equals(person2));
    }
}

class Person{
    private String name;
    private int age;
    private char gender;

    //重写
    public boolean equals(Object obj){
        if (this == obj){
            return true;
        }
        //类型判断
        if (obj instanceof Person){ //是Person，才进行比较
            Person p = (Person) obj; //向下转型
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }
        return false;
    }

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

    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;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

运行结果

其实并不是同一个对象，因为我们重写了equals方法。

8.12.4 hashCode方法

韩老师的小结：

1. 提高具有哈希结构的容器的效率
2. 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
4. 哈希值主要根据地址号得到，但是不能完全将哈希值等价于地址。
5. 在集合中，如果有需要，hashCode方法也会重写

举个栗子

package com.dingjiaxiong.object_;

/**
 * ClassName: HashCode_
 * date: 2022/9/3 13:50
 *
 * @author DingJiaxiong
 */

public class HashCode_ {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;

        System.out.println("aa.hashCode() = " + aa.hashCode());
        System.out.println("aa2.hashCode() = " + aa2.hashCode());
        System.out.println("aa3.hashCode() = " + aa3.hashCode());
    }
}

class AA{}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

运行结果

8.12.5 toString方法

【基本介绍】

默认返回：全类名+@+哈希值的十六进制

子类往往重写toString方法，用于返回对象的属性信息。

重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式。

当直接输出一个对象时，toString方法会被默认的调用。

举个栗子

package com.dingjiaxiong.object_;



/**
 * ClassName: ToString_
 * date: 2022/9/3 13:54
 *
 * @author DingJiaxiong
 */

public class ToString_ {
    public static void main(String[] args) {
        Monster monster = new Monster("小妖怪","巡山",1000);
        System.out.println(monster.toString() + " hashCode = " + monster.hashCode());

        System.out.println("==当直接输出一个对象时，toString 方法会被默认的调用==");
        System.out.println(monster);
    }
}

class Monster{
    private String name;
    private String job;
    private double sal;

    public Monster(String name, String job, double sal) {
        this.name = name;
        this.job = job;
        this.sal = sal;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

运行结果

8.12.6 finalize方法

• 当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作
• 什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用 finalize 方法。
• 垃圾回收机制的调用，是由系统来决定(即有自己的 GC 算法), 也可以通过 System.gc() 主动触发垃圾回收机制。
• 不常用

举个栗子

但是现在新版JDK中，这个方法已经弃用了，