一、Object 类的基本概念
Object类位于java.lang包下，这个基础包在Java语言中具有特殊地位。java.lang包包含了Java最核心的类和接口，例如String、System、Math等基础类。该包会在Java程序编译和运行时自动导入，因此我们在使用Object类及其相关功能时，无需在代码中显式地使用import语句。
在Java的类继承体系中，Object类处于最顶层的位置。当我们定义一个类时，如果没有显式地使用extends关键字指定其父类，那么这个类就会自动成为Object类的直接子类。例如：
public class MyClass {
// 这个类虽然没有显式继承任何类
// 但默认继承了java.lang.Object类
// 可以调用Object类的所有公共方法
}
由于所有Java类都直接或间接继承自Object类，这就意味着Object类中定义的方法在所有Java类中都是可用的。这些方法包括：
- hashCode(): 返回对象的哈希码值
- equals(): 判断对象是否相等
- toString(): 返回对象的字符串表示
- getClass(): 获取对象的运行时类
- clone(): 创建并返回对象的副本
- finalize(): 垃圾回收器调用此方法来清理资源
- wait()/notify()/notifyAll(): 线程同步相关方法
这种设计使得Java中的所有对象都具有统一的基础行为，同时也为Java的多态性提供了基础支持。例如，我们可以创建Object类型的集合来存储任何类型的对象：
List<Object> list = new ArrayList<>();
list.add("String"); // 存储字符串
list.add(123); // 存储整数
list.add(new Date()); // 存储日期对象
二、Object 类的构造方法
Object类是所有Java类的超类（父类），它包含了一个默认的无参构造方法。该构造方法的设计非常简单，其源码如下（简化版）：
public class Object {
/**
* 构造一个新创建的Object对象
*/
public Object() {
// 无任何实现
}
}
这个构造方法有以下特点：
- 访问修饰符是public，表示可以被任何类调用
- 没有参数列表
- 方法体为空，不需要任何初始化操作
在Java的对象创建机制中，当我们使用new关键字实例化一个类时，会遵循以下构造方法调用链：
- 首先调用当前类的构造方法
- 如果当前类有显式继承的父类，则会递归调用父类的构造方法
- 这个调用链会一直向上追溯，最终一定会调用到Object类的无参构造方法
例如：
class Animal {}
class Dog extends Animal {}
// 创建Dog实例时的构造方法调用顺序：
// 1. Object()
// 2. Animal()
// 3. Dog()
这种机制确保了Java对象在创建过程中，所有父类的初始化工作都能按顺序完成，从而保证对象的状态正确性。值得注意的是，即使我们不显式地在子类构造方法中使用super()调用父类构造方法，编译器也会自动插入对父类无参构造方法的调用。
三、Object 类的常用方法
Java中的Object类是所有类的根父类，它定义了一些基本方法，为所有Java对象提供了通用行为。下面我们详细解析这些方法及其使用场景。
equals()方法：对象相等性比较
基本定义
public boolean equals(Object obj)
默认实现分析
Object类中的默认实现实际上是进行引用比较：
public boolean equals(Object obj) {
return (this == obj);
}
这意味着只有当两个变量引用完全相同的对象实例时，才会返回true。
重写规范与最佳实践
重写equals()方法时，必须遵守以下五大约束条件：
-
自反性：任何非空对象x，x.equals(x)必须返回true
- 示例：
person.equals(person)必须为true
- 示例：
-
对称性：对于任何非空对象x和y，x.equals(y)必须与y.equals(x)返回相同结果
- 示例：如果
employee.equals(manager)为true，那么manager.equals(employee)也必须为true
- 示例：如果
-
传递性：对于任何非空对象x、y和z，如果x.equals(y)为true且y.equals(z)为true，那么x.equals(z)也必须为true
-
一致性：在对象未被修改的情况下，多次调用equals()应该返回相同结果
- 示例：如果两个集合内容相同，无论比较多少次都应返回true
-
非空性：对于任何非空对象x，x.equals(null)必须返回false
实现示例
public class Person {
private String name;
private int age;
private Address address; // 包含自定义类字段
@Override
public boolean equals(Object o) {
// 1. 检查是否是同一个对象
if (this == o) return true;
// 2. 检查是否为null或类型不匹配
if (o == null || getClass() != o.getClass()) return false;
// 3. 类型转换
Person person = (Person) o;
// 4. 比较关键字段
return age == person.age &&
Objects.equals(name, person.name) &&
Objects.equals(address, person.address);
}
}
hashCode()方法：对象哈希值
基本定义
public native int hashCode()
与equals()的契约关系
- 一致性：在应用程序执行期间，只要对象的equals比较中使用的信息没有被修改，多次调用hashCode()应该返回相同的整数
- 相等性：如果两个对象通过equals(Object)方法比较相等，那么它们的hashCode必须产生相同的整数结果
- 不等性建议：不相等的对象产生不同的哈希码可以提高哈希表的性能
实现示例
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((address == null) ? 0 : address.hashCode());
return result;
}
toString()方法：对象字符串表示
默认实现
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
重写建议
- 包含所有关键字段信息
- 格式清晰可读
- 考虑多线程环境下的安全性
实现示例
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", address=" + address +
'}';
}
getClass()方法：运行时类信息
基本特性
public final Class<?> getClass()
使用场景
Person p = new Person();
Class<?> cls = p.getClass();
// 获取类信息
System.out.println("Class name: " + cls.getName());
System.out.println("Simple name: " + cls.getSimpleName());
System.out.println("Superclass: " + cls.getSuperclass().getName());
// 获取方法信息
for (Method method : cls.getDeclaredMethods()) {
System.out.println("Method: " + method.getName());
}
clone()方法：对象克隆
实现要求
- 实现Cloneable接口（标记接口）
- 重写clone()方法，通常改为public访问权限
浅克隆与深克隆对比
| 特性 | 浅克隆 | 深克隆 |
|---|---|---|
| 基本类型字段 | 复制值 | 复制值 |
| 引用类型字段 | 复制引用（共享对象） | 递归创建新对象 |
| 实现复杂度 | 简单（super.clone()） | 复杂（需要递归处理） |
| 性能 | 高 | 较低 |
浅克隆示例
public class Department implements Cloneable {
private String name;
private Employee manager;
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
深克隆实现
public class Department implements Cloneable {
private String name;
private Employee manager;
@Override
public Object clone() throws CloneNotSupportedException {
Department cloned = (Department) super.clone();
// 对引用类型进行深拷贝
cloned.manager = (Employee) manager.clone();
return cloned;
}
}
finalize()方法：对象终结
基本定义
protected void finalize() throws Throwable
替代方案（Java 9+推荐）
-
AutoCloseable接口：配合try-with-resources使用
public class Resource implements AutoCloseable { @Override public void close() { // 明确的资源释放逻辑 } } -
Cleaner API（Java 9引入）：
public class Room implements AutoCloseable { private static final Cleaner cleaner = Cleaner.create(); private static class State implements Runnable { @Override public void run() { // 清理逻辑 } } private final State state; private final Cleaner.Cleanable cleanable; public Room() { this.state = new State(); this.cleanable = cleaner.register(this, state); } @Override public void close() { cleanable.clean(); } }
使用建议
- 避免依赖finalize()进行资源清理
- 优先使用try-with-resources或显式的close()方法
- 在必须使用finalize()的情况下，确保调用super.finalize()
四、其他方法
1.wait() 方法详解
wait()方法是Object类中定义的核心方法，用于线程间通信，它有三个重载版本：
1.1 基本版本：
public final void wait() throws InterruptedException
- 使当前线程无限期等待，直到其他线程调用notify()或notifyAll()方法
- 会释放当前线程持有的对象锁
- 可能抛出InterruptedException异常
1.2 超时版本：
public final void wait(long timeout) throws InterruptedException
- 使当前线程等待指定的毫秒数
- 如果超时前没有被唤醒，线程会自动恢复执行
- 典型应用场景：实现带有超时机制的线程同步
1.3 高精度超时版本：
public final void wait(long timeout, int nanos) throws InterruptedException
- 提供纳秒级的超时控制
- 实际精度取决于系统实现
- 参数范围：0 ≤ nanos ≤ 999999
重要注意事项：
- 调用wait()前线程必须获得对象锁（即要在synchronized块内调用）
- 调用后会释放锁，允许其他线程获取该锁
- 被唤醒后需要重新获取锁才能继续执行
- 典型使用模式：
synchronized(obj) {
while(条件不满足) {
obj.wait();
}
// 执行操作
}
2.notify()和notifyAll()方法详解
2.1 notify()方法：
public final void notify()
- 随机唤醒一个在该对象上等待的线程
- 被唤醒的线程需要重新获取对象锁才能继续执行
- 如果多个线程在等待，选择策略由JVM实现决定
2.2 notifyAll()方法：
public final void notifyAll()
- 唤醒所有在该对象上等待的线程
- 这些线程会竞争获取对象锁
- 最终只有一个线程能获得锁并执行
关键区别：
- notify()更高效但可能导致某些线程"饥饿"
- notifyAll()更公平但可能引起"惊群效应"
- 根据实际场景选择合适的方法
使用规范：
- 必须在持有对象锁时调用（synchronized块内）
- 调用后不会立即释放锁，要等到synchronized块结束
- 通常与wait()配合使用实现线程间通信
- 典型使用模式：
synchronized(obj) {
// 修改共享状态
obj.notify(); // 或notifyAll()
}
应用场景示例：
- 生产者-消费者模型
- 线程池任务调度
- 事件驱动编程
- 资源池管理
注意事项：
- 这些方法都是final方法，不能重写
- 调用这些方法的对象必须作为同步锁对象
- 不当使用可能导致死锁或活锁
- Java 5+推荐使用java.util.concurrent包中的高级同步工具
扫一扫
171万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
