第43章 Object类

作者：张子默

一、概述

java.lang.Object类是Java语言中的根类，即所有类的父类。该类中描述的所有方法子类都可以使用。在对象实例化的时候，最终找到的父类就是Object。

如果一个类没有特别指定父类，那么默认则继承Object类。例如：

public class MyClass /*extends Object*/ {
	// ...
}
1
2
3

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。这里主要讲述其中的2个：

• public String toString()：返回该对象的字符串表示。
• public boolean equals(Object obj)：指示其他某个对象是否与此对象"相等"。

二、toString方法

1、方法摘要

• public String toString()：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址。

由于toString方法返回的是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此需要重写它。

2、覆盖重写

如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

public class Person {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
    // 省略构造器与Getter Setter
}
1
2
3
4
5
6
7
8
9

小贴士：在我们直接使用输出语句输出对象名的时候，其实通过该对象调用了其toString()方法。

三、equals方法

1、方法摘要

• public boolean equals(Object obj)：指示其他某个对象是否与此对象"相等"。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否相同。这里的"相同"有默认和自定义两种方式。

2、默认地址比较

如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

3、对象内容比较

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

import java.util.Objects;
public class Person {
    private String name;
    private int age;
    @Override
    public boolean equals(Object o) {
        // 如果对象地址一样，则认为相同
        if (this == o)
        	return true;
        // 如果参数为空，或者类型信息不一样，则认为不同
        if (o == null || getClass() != o.getClass())
        	return false;
        // 转换为当前类型
        Person person = (Person) o;
        // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age && Objects.equals(name, person.name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

四、Objects类

在JDK 7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的使用方法组成，这些方法是null-save(空指针安全的)或null-tolerant(容忍空指针的)，用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题，方法如下：

• public static boolean equals(Object a, Object b)：判断两个对象是否相等。

我们可以查看一下源码，学习一下：

public static boolean equals(Object a, Object b) {
	return (a == b) || (a != null && a.equals(b));
}
1
2
3

五、实例

package com.zzm.day12.demo01;

import java.util.Objects;

/**
 * 用途：
 * 时间：2021/6/27 10:05
 * 创建人：张子默
 */
public class Person {

    private String name;
    private int age;

    public Person() {
    }

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

    /*
    直接打印对象的地址没有意义，需要重写Object类中的toString方法
    打印对象的属性(name, age)
     */

    /*@Override
    public String toString() {
        // return "abc";
        return "Person{name=" + name + " ,age=" + age + "}";
    }*/

    /*@Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                "}";
    }*/

    /*
    Object类的equals方法，默认比较的是两个对象的地址值，没有意义
    所以我们要重写equals方法，比较两个对象的属性(name， age)
    问题：
        隐含着一个多态
        多态的弊端：无法使用子类特有的内容(属性和方法)
        Object obj = p2 = new Person("古力娜扎", 19);
        解决：可以使用向下转型(强转)把obj转换成Person
     */
    /*@Override
    public boolean equals(Object obj) {
        // 增加一个判断，传递的参数obj如果是this本身，直接返回true，提高程序效率
        if (obj == this) {
            return true;
        }

        // 增加一个判断，传递的参数obj如果是null，直接返回false，提高程序的效率
        if (obj == null) {
            return false;
        }

        // 增加一个判断，防止类型转换异常ClassCastException
        if (obj instanceof Person) {
            // 使用向下转型，把obj转换为Person类型
            Person p = (Person) obj;
            // 比较两个对象的属性，一个对象是this(p1)，一个对象是p(obj -> p2)
            boolean b = this.name.equals(p.name) && this.age == p.age;
            return b;
        }
        // 不是Person类型直接返回false
        return false;
    }*/

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        // getClass() != o.getClass() 使用反射技术，判断o是否是Person类型 等效于obj instanceof Person
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

package com.zzm.day12.demo01;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/**
 * 用途：
 * 时间：2021/6/27 9:59
 * 创建人：张子默
 */

/*
java.lang.Object
类Object是类层次结构的根(父)类。
每个类(Person,Student...)都使用Object作为超(父)类。
所有对象(包括数组)都实现这个类的方法
 */
public class Demo01ToString {

    public static void main(String[] args) {
        /*
        Person类默认继承了Object类，所以可以使用Object类中的toString方法
        String toString() 返回该对象的字符串表示。
         */
        Person p = new Person("张三", 18);
        String s = p.toString();
        System.out.println(s); // com.zzm.day12.demo01.Person@75412c2f | abc | Person{name=张三 ,age=18}

        // 直接打印对象的名字，其实就是调用对象的toString p=p.toString();
        System.out.println(p); // com.itheima.demo01.Object.Person@75412c2f | abc | Person{name=张三 ,age=18}

        // 看一个类是否重写了toString，直接打印这个类的对象即可，如果没有重写toString方法，那么打印的是对象的地址值
        Random r = new Random();
        System.out.println(r); // java.util.Random@13b6d03  没有重写toString方法

        Scanner sc = new Scanner(System.in);
        System.out.println(sc); // java.util.Scanner[delimiters=\p{javaWhitespace}+][position=0][match valid=false][need input=false][source closed=false][skipped=false][group separator=\,][decimal separator=\.][positive prefix=][negative prefix=\Q-\E][positive suffix=][negative suffix=][NaN string=\QNaN\E][infinity string=\Q∞\E] 重写toString方法

        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list); // [1, 2, 3] 重写toString方法
    }

}

package com.zzm.day12.demo01;

import java.util.ArrayList;

/**
 * 用途：
 * 时间：2021/6/27 10:23
 * 创建人：张子默
 */
public class Demo02Equals {

    public static void main(String[] args) {
        /*
        Person类默认继承了Object类，所以可以使用Object类的equals方法
        boolean equals(Object obj)：指示其他某个对象是否与此对象"相等"。
        equals方法的源码：
            public boolean equals(Object obj) {
                return (this == obj);
            }
            参数：
                Object obj：可以传递任意的对象
                    ==比较运算符，返回的是一个布尔值 true false
                        基本数据类型：比较的是值
                        引用数据类型：比较的是地址值
                哪个对象调用的方法，方法中的this就是那个对象；p1调用的equals方法所以this就是p1
                obj是传递过来的参数p2
                this == obj --> p1 == p2
         */
        Person p1 = new Person("迪丽热巴", 18);
        // Person p2 = new Person("古力娜扎", 19);
        Person p2 = new Person("迪丽热巴", 18);
        System.out.println("p1：" + p1); // p1：com.zzm.day12.demo01.Person@7c30a502
        System.out.println("p2：" + p2); // p2：com.zzm.day12.demo01.Person@49e4cb85

        // p1 = p2; // 把p2的地址值赋值给p1
        ArrayList<String> list = new ArrayList<>();

        boolean b = p1.equals(p1);
        System.out.println(b);
    }

}

package com.zzm.day12.demo01;

import java.util.Objects;

public class Demo03Objects {

    public static void main(String[] args) {
        // String s1 = "abc";
        String s1 = null;
        String s2 = "abc";
        // boolean b = s1.equals(s2); // NullPointerException null是不能调用方法的，就会抛出空指针异常
        // System.out.println(b);

        /*
        Objects类的equals方法：对两个对象进行比较，防止空指针异常
        public static boolean equals(Object a, Object b) {
            return (a == b) || (a != null && a.equals(b));
        }
         */
        boolean b2 = Objects.equals(s1, s2);
        System.out.println(b2);
    }

}
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221