当前位置：首页 > news >正文

Java Object 类

news 2026/6/7 13:45:53

Java Object 类学习笔记（详细版）

一、Object 类概述

java.lang.Object是 Java 类层次结构的根类（超类）。

唯一性：Java 中所有的类都直接或间接地继承自Object类。
隐式继承：如果你定义一个类没有显式继承其他类（如class A {}），编译器会自动让它继承Object（即class A extends Object {}）。
核心作用：它定义了所有对象共有的基本行为，如对象标识、字符串表示、哈希码计算、对象克隆、线程同步等。

重要提示：Object类位于java.lang包中，该包会被自动导入，因此使用Object类时无需手动import。

二、核心方法详解

Object类中定义了 11 个方法，其中 9 个是public，2 个是protected。以下是重点方法的详细解析：

1.`equals(Object obj)`

作用：判断两个对象是否“相等”。
默认行为：比较两个对象的内存地址（即==操作符的行为）。
重写建议：对于自定义类，通常需要根据对象的内容（字段值）来判断相等性，必须重写此方法。

publicclassPerson{privateStringname;privateintage;publicPerson(Stringname,intage){this.name=name;this.age=age;}// 重写 equals 方法@Overridepublicbooleanequals(Objectobj){// 1. 自反性检查：同一个对象if(this==obj)returntrue;// 2. 空值检查if(obj==null)returnfalse;// 3. 类型检查if(getClass()!=obj.getClass())returnfalse;Personother=(Person)obj;// 4. 字段比较 (注意处理 null)if(age!=other.age)returnfalse;if(name==null){if(other.name!=null)returnfalse;}elseif(!name.equals(other.name))returnfalse;returntrue;}}

⚠️ 黄金法则：如果重写了equals()，必须同时重写hashCode()，否则会导致在HashMap、HashSet等集合中无法正常工作。

2.`hashCode()`

作用：返回对象的哈希码（整数），用于哈希表（如HashMap、HashSet）中确定对象的存储位置。
默认行为：通常基于对象的内存地址计算出一个整数。
重写规则：

在程序运行期间，只要对象用于equals比较的字段没有被修改，hashCode必须保持一致。
如果a.equals(b)为true，则a.hashCode()必须等于b.hashCode()。
如果a.hashCode() == b.hashCode()，a.equals(b)不一定为true（哈希冲突）。

@OverridepublicinthashCode(){// 使用 Objects 工具类 (Java 7+) 或手动计算returnjava.util.Objects.hash(name,age);// 或者手动计算：int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result;}

3.`toString()`

作用：返回对象的字符串表示，用于调试、日志打印。
默认行为：返回"类名@哈希码的十六进制"（例如：com.example.Person@15db9742）。
重写建议：通常重写以返回对象的关键字段信息，便于阅读。

@OverridepublicStringtoString(){return"Person{name='"+name+"', age="+age+"}";}// 使用Personp=newPerson("张三",25);System.out.println(p);// 输出：Person{name='张三', age=25} (如果重写了)// 输出：com.example.Person@15db9742 (如果未重写)

4.`clone()`

作用：创建并返回对象的一个副本（浅拷贝）。
访问修饰符：protected。
前提条件：

类必须实现Cloneable接口（标记接口，无方法），否则抛出CloneNotSupportedException。
必须重写clone()方法并改为public。

浅拷贝 vs 深拷贝：

浅拷贝：复制基本类型字段，引用类型字段只复制引用地址（原对象和克隆对象共享引用对象）。
深拷贝：递归复制所有引用对象，完全独立。

classStudentimplementsCloneable{privateStringname;privateintage;publicStudent(Stringname,intage){this.name=name;this.age=age;}@OverrideprotectedObjectclone()throwsCloneNotSupportedException{returnsuper.clone();// 浅拷贝}}// 使用Students1=newStudent("李四",20);Students2=(Student)s1.clone();System.out.println(s1==s2);// false (地址不同)

注意：由于clone()机制复杂且容易出错（特别是深拷贝），现代 Java 开发中更推荐使用复制构造函数或拷贝工厂方法来实现对象复制。

5.`getClass()`

作用：返回对象运行时的Class对象。
用途：反射、类型检查。

Personp=newPerson("王五",30);Class<?>clazz=p.getClass();System.out.println(clazz.getName());// 输出：com.example.Person

6.`finalize()`

作用：在对象被垃圾回收器（GC）回收之前调用。
状态：已废弃 (Deprecated)(Java 9+)。
原因：执行时间不确定，性能差，可能导致对象复活，不推荐依赖它进行资源清理。
替代方案：使用try-with-resources、Cleaner或PhantomReference。

7.`notify()`,`notifyAll()`,`wait()`

作用：用于多线程间的线程通信（对象监视器）。
前提：必须在synchronized代码块或方法中调用，否则抛出IllegalMonitorStateException。

wait(): 释放锁，让当前线程进入等待状态，直到其他线程调用notify()或notifyAll()。
notify(): 唤醒一个在此对象监视器上等待的线程。
notifyAll(): 唤醒所有在此对象监视器上等待的线程。

synchronized(lockObject){while(!condition){lockObject.wait();// 等待}// 执行操作lockObject.notifyAll();// 通知}

8.`wait(long timeout)`/`wait(long timeout, int nanos)`

作用：带超时的等待。如果指定时间内未被唤醒，线程会自动继续执行。

9.`hashCode()`与`equals()`的契约（面试重点）

规则	说明
一致性	多次调用`hashCode()`应返回相同值（只要对象用于`equals`的字段未变）。
相等性	如果`a.equals(b)`为`true`，则`a.hashCode()`必须等于`b.hashCode()`。
不等性	如果`a.hashCode() == b.hashCode()`，`a.equals(b)`不一定为`true`（哈希冲突允许）。
非空	`hashCode()`不应为`null`（返回 int，天然非空）。

三、常用工具类：`java.util.Objects`

从 Java 7 开始，引入了Objects工具类，简化了Object方法的调用，避免NullPointerException。

方法	说明
`Objects.equals(a, b)`	安全比较，处理 null 值。`a == b
`Objects.hashCode(o)`	安全获取哈希码，null 返回 0。
`Objects.requireNonNull(o)`	如果 o 为 null，抛出 NPE；否则返回 o。
`Objects.toString(o)`	安全转字符串，null 返回 “null”。
`Objects.deepEquals(a, b)`	深度比较数组内容。

示例：

// 重写 equals 的简化写法@Overridepublicbooleanequals(Objectobj){if(this==obj)returntrue;if(obj==null||getClass()!=obj.getClass())returnfalse;Personperson=(Person)obj;returnage==person.age&&Objects.equals(name,person.name);// 安全比较}@OverridepublicinthashCode(){returnObjects.hash(name,age);// 自动生成哈希码}

四、实战场景与最佳实践

1. 为什么必须重写`equals`和`hashCode`？

场景：将自定义对象放入HashSet或作为HashMap的 Key。
后果：如果不重写，默认比较内存地址。即使两个对象内容完全一样，也被视为不同元素，导致：

HashSet中出现重复元素。
HashMap中无法通过新对象 Key 获取到旧 Value。

2. 如何正确生成`equals`和`hashCode`？

IDE 生成：IntelliJ IDEA 或 Eclipse 中，右键 -> Generate ->equals()andhashCode()。
Lombok：使用@Data或@EqualsAndHashCode注解自动生成。
手动编写：遵循上述规则，使用Objects工具类。

3. 不可变类（Immutable Class）

如果类是不可变的（如String、Integer），其hashCode可以缓存，提高性能。

publicfinalclassImmutablePerson{privatefinalStringname;privatefinalintage;privateinthashCode=0;// 缓存// 构造函数...@OverridepublicinthashCode(){if(hashCode==0){hashCode=Objects.hash(name,age);}returnhashCode;}}

4. 深拷贝的实现

如果对象包含引用类型字段，clone()是浅拷贝。实现深拷贝需要手动递归克隆引用对象。

@OverrideprotectedObjectclone()throwsCloneNotSupportedException{// 浅拷贝Studentcloned=(Student)super.clone();// 深拷贝引用字段 (假设 Address 也实现了 Cloneable)if(this.address!=null){cloned.address=(Address)this.address.clone();}returncloned;}

五、常见面试题

Q1:`==`和`equals()`的区别？

==：
- 基本类型：比较值。
- 引用类型：比较内存地址（是否同一个对象）。
equals()：
- 默认（Object）：比较内存地址（同==）。
- 重写后（如 String, Person）：比较对象内容。

Q2: 为什么 String 重写了`equals`和`hashCode`？

因为 String 经常作为HashMap的 Key 或HashSet的元素。
我们需要根据字符串的内容来判断是否相等，而不是内存地址。
String 的hashCode被缓存，因为 String 是不可变的，哈希值不会变，性能极高。

Q3: 如果只重写`equals`不重写`hashCode`会发生什么？

违反 Java 规范。
在HashMap中：两个逻辑相等的对象，hashCode不同，会被放入不同的桶（Bucket）。
结果：map.put(key1, val)后，map.get(key2)（key1.equals(key2) 为 true）返回null。

Q4:`clone()`和`new`的区别？

new：调用构造函数，从头创建新对象。
clone()：在内存中复制现有对象的二进制位，不调用构造函数（除非在 clone 方法内部显式调用）。
clone()通常比new快（对于复杂对象），但实现复杂且易错。

Q5:`wait()`和`sleep()`的区别？

特性	`wait()`	`sleep()`
所属类	`Object`	`Thread`
锁释放	释放锁	不释放锁
唤醒方式	`notify()`/`notifyAll()`或超时	时间到或被`interrupt()`
使用范围	必须在`synchronized`中	任意位置