Object常用方法
Object常用方法目录
1. equals(Object obj)：
2. toString()：
3. hashCode()：
4. getClass()：
5. notify() 和 notifyAll()：
6. wait() 和 wait(long timeout)：
7. clone()：
8. finalize()：
在 Java 中，Object 是所有类的超类，其中定义了一些常用的方法。Object常用方法有：toString()、equals()、hashCode()、clone()等。以下是几个常用的 Object 方法：
1. equals(Object obj)：
判断当前对象是否与另一个对象相等。通常需要重写该方法来自定义相等的逻辑。
2. toString()：
返回当前对象的字符串表示。通常需要重写该方法来自定义对象的字符串表示。
3. hashCode()：
返回当前对象的哈希码。通常需要与 equals 方法配合使用。
4. getClass()：
返回当前对象的类对象。
/**
* @author Evan Walker 昂焱科技
* @version 1.0
* @desc
* @date 2023/10/31 23:10:36
*/
public class Room {
private Integer id;
private String name;
public Room(Integer id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Room{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
public static void main(String[] args) {
String name = "昂焱科技会议室";
Room p1 = new Room(18, name);
Room p2 = new Room(18, name);
// 1. equals(Object obj)：
System.out.println(p1.equals(p2));
// 2. toString()：
System.out.println(p1.toString());
// 3. hashCode()：
System.out.println(p1.hashCode());
// 4. getClass()：
System.out.println(p1.getClass());
}
}
5. notify() 和 notifyAll()：
唤醒一个或多个正在等待当前对象锁的线程。
notify
- 用法：
public final void notify() - 功能：唤醒正在等待当前对象锁的单个线程。如果有多个线程在等待，但只能有一个线程被唤醒。哪个线程被唤醒是不确定的，取决于 JVM 的调度。
- 注意事项：
- 调用
notify()方法的前提是当前线程已经获取了对象的锁（即在同步代码块或同步方法中）。 notify()方法只会唤醒等待队列中的一个线程，无法确定是哪个线程被唤醒。
- 调用
notifyAll
- 用法：
public final void notifyAll() - 功能：唤醒正在等待当前对象锁的所有线程，让它们竞争获取锁。
- 注意事项：
- 调用
notifyAll()方法的前提是当前线程已经获取了对象的锁（即在同步代码块或同步方法中）。 notifyAll()方法会唤醒等待队列中的所有线程，让它们开始竞争获取锁。但是只有一个线程能够获取到锁并继续执行，其他线程将继续等待。
- 调用
6. wait() 和 wait(long timeout)：
使当前线程等待，直到另一个线程调用当前对象的 notify() 或 notifyAll() 方法唤醒它，或者等待超时。
wait
- 用法：
public final void wait() throws InterruptedException - 功能：使当前线程进入等待状态，直到其他线程调用相同对象的
notify()或notifyAll()方法来唤醒它。 - 注意事项：
- 调用
wait()方法的前提是当前线程已经获取了对象的锁（即在同步代码块或同步方法中）。 wait()方法会释放对象的锁，让其他线程有机会获取锁并执行。- 在被唤醒之后，线程需要重新竞争获取对象的锁才能继续执行。
- 调用
wait(long timeout)
- 用法：
public final void wait(long timeout) throws InterruptedException - 功能：使当前线程进入等待状态，并在指定的时间范围内等待，直到其他线程调用相同对象的
notify()或notifyAll()方法来唤醒它，或者超过指定的时间。 - 参数：
timeout：等待的时间（以毫秒为单位）。如果超过该时间，线程将自动唤醒。
- 注意事项：
- 调用
wait(long timeout)方法的前提是当前线程已经获取了对象的锁（即在同步代码块或同步方法中）。 wait(long timeout)方法会释放对象的锁，并在等待指定的时间内进入等待状态。- 在被唤醒之后，线程需要重新竞争获取对象的锁才能继续执行。
- 如果等待时间超过指定的时间，则线程会自动唤醒。
- 调用
/**
* @author Evan Walker 昂焱科技
* @version 1.0
* @desc
* @date 2023/11/01 19:54:22
*/
public class TestDemo {
public static void main(String[] args) throws InterruptedException {
Object locker = new Object();
Thread t1 = new Thread(() -> {
try {
System.out.println("wait开始");
synchronized (locker) {
// 6. wait() 和 wait(long timeout)：
locker.wait();
// locker.wait(3000L);
}
System.out.println("wait结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
t1.start();
//保证t1先启动，wait()先执行
Thread.sleep(1000);
Thread t2 = new Thread(() -> {
synchronized (locker) {
System.out.println("notify开始");
// notify() 和 notifyAll()：
locker.notify();
// locker.notifyAll();
System.out.println("notify结束");
}
});
t2.start();
}
}7. clone()：
创建并返回当前对象的副本。通常需要实现 Cloneable 接口才能使用该方法。
clone() 方法用于创建并返回一个对象的副本，这个副本与原始对象完全相同（包括数据和状态），但是它们在内存中的地址不同。也就是说，使用 clone() 方法可以创建一个新的对象，而不需要再次调用构造函数。
clone() 方法是一个受保护的方法，因此只能在具有适当权限的同一类或其子类中访问。为了对外公开，通常需要重写 Object 类中的 clone() 方法，并将其声明为 public 类型。
/**
* @author Evan Walker 昂焱科技
* @version 1.0
* @desc
* @date 2023/11/02 21:38:03
*/
public class CloneDemo implements Cloneable{
private int value;
public CloneDemo(int value) {
this.value = value;
}
public int getValue() {
return value;
}
@Override
public CloneDemo clone() throws CloneNotSupportedException {
return (CloneDemo) super.clone();
}
} 在上面的示例中，我们首先声明了一个 CloneDemo 类，并实现了 Cloneable 接口以指示该类支持克隆操作。然后，我们重写了 Object 类中的 clone() 方法，并将其声明为 public 类型。
在 clone() 方法的实现中，我们首先调用了 super.clone() 方法获取 CloneDemo 类的浅副本，之后将其强制转换成 MyClass 类型并返回。这样，我们就可以通过调用 clone() 方法来创建 CloneDemo 类的一个副本。
需要注意的是，使用 clone() 方法进行对象复制时，如果对象中包含其他对象的引用，那么实际上只会复制这些引用而不是它们所引用的对象。也就是说，被复制的对象和其副本之间可能会共享一些数据结构，这样可能会导致副本对象与原始对象在内存中存在交叉引用的问题。为了避免这种问题，可以采用深度克隆方法或其他方式进行修改。
8. finalize()：
当对象被垃圾回收器回收时，系统会调用该方法，通常用于对象资源的清理。
在 Java 中，finalize() 方法是一个被废弃的方法，在最新版本的 Java 中已经不推荐使用。它是定义在 Object 类中的一个方法，其作用是在对象被垃圾回收之前执行一些清理操作。
然而，由于 finalize() 方法存在性能、可靠性和安全性等方面的问题，Java 社区建议使用其他机制来进行资源释放和清理操作，如使用 try-with-resources 块或显式地关闭资源。
以下是一个使用 try-with-resources 块关闭文件流的示例：
try (FileInputStream fis = new FileInputStream("file.txt")) {
// 使用文件流进行读取或写入操作
} catch (IOException e) {
// 处理异常
} 在上述示例中，通过将文件流的创建和使用放在 try 括号内，Java 会在代码块执行完毕后自动关闭文件流，无需显式地调用 close() 方法。
总结起来，避免使用 finalize() 方法，而是倾向于使用更可靠和明确的方式来释放资源。
这些方法都是 Object 类中定义的方法，因此在任何类中都可以使用它们。此外，由于 Java 中的所有类都是继承自 Object 类的，因此这些方法在每个类中都有默认的实现，但有时候需要根据具体情况进行重写以实现特定的行为。
更多消息资讯，请访问昂焱数据（https://www.ayshuju.com）