Java基础(九)：Object核心类深度剖析

public class Object {
    private static native void registerNatives();
    static {
        registerNatives();
    }

    public final native Class<?> getClass();
    public native int hashCode();
    public boolean equals(Object obj) { return this == obj; }
    protected native Object clone() throws CloneNotSupportedException;
    public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }
    public final native void notify();
    public final native void notifyAll();
    public final native void wait(long timeout) throws InterruptedException;
    public final void wait(long timeout, int nanos) throws InterruptedException;
    public final void wait() throws InterruptedException;
    protected void finalize() throws Throwable { }
}

public static void main(String[] args) {
	Object obj = new Person();
	System.out.println(obj.getClass());//运行时类型
}
// 输出结果
class com.atguigu.java.Person

@Override
public boolean equals(Object o) {
	// 如果是同一个对象，直接返回true
    if (this == o) return true;
    
    // 如果传入的对象是null或者不是同一个类，直接返回false
    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); // 使用JDK工具类
}

public int hashCode() {
    int h = 0;
    for (int i = 0; i < value.length; i++) {
        h = 31 * h + value[i];
    }
    return h;
}

public int hashCode() {
    return value;
}

public int hashCode() {
	// ht 是一个 64 位的长整型（long），它表示时间戳
    long ht = this.getTime();
    // 对低 32 位和高 32 位的哈希值进行异或，得到最终的哈希值
    return (int) ht ^ (int) (ht >> 32);
}

// Objects类方法
public static int hash(Object... values) {
    return Arrays.hashCode(values);
}
// Arrays类方法
public static int hashCode(Object a[]) {
    if (a == null){
        return 0;
	}
    int result = 1;

    for (Object element : a){
    	// 31这个数字是为了尽量的减少hash冲突
        result = 31 * result + (element == null ? 0 : element.hashCode());
	}
    return result;
}

public class User {
    private String name;
    private Integer age;
    
    public User(String name,Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("equals...");
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equal(name, user.name);
    }

    @Override
    public int hashCode() {
        System.out.println("hashCode...");
        return Objects.hashCode(name, age);
    }
}

public class Test {
    public static void main(String[] args) {
        Set<User> set = new HashSet<>();
        User u1  = new User("张三",3);
        User u2  = new User("张三",3);
        set.add(u1);
        set.add(u2);
        System.out.println("set size:"+ set.size());
    }
}

hashCode...
hashCode...
equals...
set size:1

public class Person implements Cloneable {
    private String name;
    private int age;

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

    // Getter & Setter 略...

    @Override
    public Person clone() throws CloneNotSupportedException {
        return (Person) super.clone(); // 调用 Object 的 clone() 方法
    }

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

@Override
public String toString() {
    return "Person{" +
           "name='" + name + '\'' +
           ", age=" + age +
           '}';
}
// 输出：Person{name='Alice', age=30}

class SharedResource {
    private boolean ready = false;
	
	// 消费者​ 线程发现数据没准备好，就调用 wait()​等待，直到被叫醒获取锁才能执行
    public synchronized void consume() throws InterruptedException {
        while (!ready) {
            System.out.println("消费者：数据未准备好，等待中...");
            wait(); // 等待生产者通知
        }
        System.out.println("消费者：数据已消费");
        ready = false; // 重置状态
    }
	
	// 生产者​ 线程准备好数据后，调用 notify()或 notifyAll()​叫醒消费者
    public synchronized void produce() {
        // 模拟生产
        ready = true;
        System.out.println("生产者：数据已准备好，通知消费者");
        notifyAll(); // 唤醒所有等待的消费者线程
    }
}