问：Java中Object类常用方法及使用场景有哪些？

在Java中，Object类是所有类的根类，意味着每个类都直接或间接地继承了Object类。因此，Object类提供的方法对于Java中的每个对象都是可用的。下面将详细讨论Object类的一些核心常用方法，包括它们的功能、使用场景和参数。

1. equals(Object obj)

功能

equals(Object obj)方法用于判断两个对象是否相等。默认情况下，它比较的是对象的内存地址（即是否为同一个对象实例）。

使用场景

当需要基于对象的内容（而非引用）来比较两个对象是否相等时，应覆盖此方法。

参数

• Object obj：要与之比较的对象。

示例

class Person {
    String name;
    int age;

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

    // 覆盖equals方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age &&
               Objects.equals(name, person.name);
    }

    // 测试
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 30);
        Person p2 = new Person("Alice", 30);
        System.out.println(p1.equals(p2)); // 输出true
    }
}

2. hashCode()

功能

hashCode()方法返回对象的哈希码值。这个值用于确定对象在哈希表中的索引位置。

使用场景

当重写equals(Object obj)方法时，通常也需要重写hashCode()方法，以保持equals()和hashCode()的一致性契约。

示例

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

3. toString()

功能

toString()方法返回对象的字符串表示。默认情况下，返回的是对象的类名@无符号十六进制哈希码的无意义字符串。

使用场景

需要输出对象的详细信息或调试时，可以覆盖此方法以返回对象的属性信息。

示例

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

4. clone()

功能

clone()方法创建并返回对象的一个副本。此方法受保护，子类可以通过覆盖此方法并提供公共方法来支持克隆。

使用场景

需要深拷贝对象时。

注意

默认是浅拷贝，如果要实现深拷贝，需要在子类中覆盖此方法，并处理对象的内部字段的克隆。

示例（简化版，不涉及深拷贝）

@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
}

5. getClass()

功能

getClass()方法返回对象的运行时类。

使用场景

需要动态获取对象的类信息时，如反射。

示例

Person p = new Person("Alice", 30);
System.out.println(p.getClass().getName()); // 输出Person类的全名

6. finalize()

功能

finalize()方法在垃圾回收器决定回收某对象时，会先调用此对象的finalize()方法。但是，finalize()的调用是不确定的，不能保证对象被垃圾回收时一定会被调用。

使用场景

释放非Java内存资源（如文件句柄或网络连接）。但是，通常不建议使用此方法管理资源，而应该使用try-with-resources语句或显式的关闭方法。

注意

在Java 9及更高版本中，finalize()方法已被标记为已弃用。

示例（不推荐使用）

@Override
protected void finalize() throws Throwable {
    super.finalize();
    // 释放资源
}

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

功能

wait(), notify(), 和 notifyAll() 是Object类中的方法，用于线程之间的通信，特别是在多线程环境下。

7.1 wait()，notify()

wait() 方法导致当前线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。调用 wait() 方法的线程必须拥有该对象的锁（即它必须是同步块或同步方法的一部分）。当线程调用 wait() 时，它会释放锁并暂停执行，直到另一个线程调用同一个对象的 notify() 或 notifyAll() 方法，并且当前线程重新获得该对象的锁。

wait() 方法有几种形式，但最常见的是无参数的 wait() 和带有超时时间的 wait(long timeout)。还有一个带有超时和纳秒调整的 wait(long timeout, int nanos)，但不太常用。

示例代码

以下是一个简单的示例，展示了如何使用 wait() 和 notify() 方法来同步两个线程之间的操作。在这个例子中，我们有一个生产者线程和一个消费者线程，生产者生成数据并通知消费者，而消费者等待数据。

public class ProducerConsumerExample {
    private final Object lock = new Object(); // 用于同步的锁对象
    private boolean hasData = false; // 标记是否有数据

    // 生产者线程
    public void produce() {
        synchronized (lock) {
            while (hasData) {
                try {
                    // 如果没有空间，生产者等待
                    lock.wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 保持中断状态
                }
            }

            // 模拟数据生产
            System.out.println("Produced data");
            hasData = true;
            // 通知消费者
            lock.notify();
        }
    }

    // 消费者线程
    public void consume() {
        synchronized (lock) {
            while (!hasData) {
                try {
                    // 如果没有数据，消费者等待
                    lock.wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 保持中断状态
                }
            }

            // 模拟数据消费
            System.out.println("Consumed data");
            hasData = false;
            // 通知生产者（虽然在这个例子中不是严格必需的，但展示了如何使用notify）
            lock.notify();
        }
    }

    public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample();

        // 生产者线程
        Thread producer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.produce();
                try {
                    Thread.sleep(1000); // 模拟生产耗时
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.consume();
                try {
                    Thread.sleep(2000); // 模拟消费耗时
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        producer.start();
        consumer.start();
    }
}

示例中，lock 对象被用作同步锁。生产者在生产数据之前会检查 hasData 标记，如果已经有数据，它会通过 wait() 等待。类似地，消费者在消费数据之前也会等待直到有数据。通过调用 notify()（或更合适的 notifyAll()，以防有多个线程在等待），一个线程可以唤醒等待在相同锁上的其他线程。注意，这里的 notify() 可能不足以唤醒所有等待的线程，如果需要唤醒所有等待的线程，则应使用 notifyAll()。

结语

Object类作为Java中所有类的基类，提供了许多基础且重要的方法。这些方法在面向对象的编程中发挥着关键作用，从比较对象是否相等（equals()），到获取对象的哈希码值（hashCode()），再到输出对象的字符串表示（toString()），以及更高级的线程间通信机制（wait(), notify(), notifyAll()）。了解并熟练掌握这些方法，对于编写健壮、可维护的Java代码至关重要。随着Java版本的更新，一些方法（如 finalize()）已被弃用，因此在实践中应关注最新的官方文档。