Java中对象相等性、哈希码与克隆的深度解析与最佳实践

import java.util.Objects;

public abstract class Superclass {
    private String name;
    private int hp;

    public Superclass(String name, int hp) {
        this.name = name;
        this.hp = hp;
    }

    public String getName() {
        return name;
    }

    public int getHp() {
        return hp;
    }

    @Override
    public boolean equals(Object obj) {
        // 1. 自反性：检查是否是同一个对象的引用
        if (this == obj) {
            return true;
        }
        // 2. 非空性：检查obj是否为null
        if (obj == null) {
            return false;
        }
        // 3. 类型检查：使用getClass()确保类型严格一致，或使用instanceof允许子类比较
        // 这里使用getClass()保证严格的类型相等，通常推荐这种做法，除非有特殊继承需求
        if (getClass() != obj.getClass()) {
            return false;
        }

        // 4. 类型转换：将obj转换为当前类型
        Superclass other = (Superclass) obj;

        // 5. 字段比较：比较所有用于定义相等性的字段
        return Objects.equals(this.name, other.name) && // 使用Objects.equals处理可能为null的字段
               this.hp == other.hp;
    }

    @Override
    public int hashCode() {
        // 结合所有用于equals()比较的字段的哈希码
        // Objects.hash() 是一个方便的工具，可以处理null值
        return Objects.hash(name, hp);
        // 如果手动计算，通常使用质数乘法：
        // int result = 17; // 任意非零质数
        // result = 31 * result + (name != null ? name.hashCode() : 0);
        // result = 31 * result + hp;
        // return result;
    }

    @Override
    public String toString() {
        // toString() 仅用于表示对象信息，不用于相等性判断
        return getClass().getSimpleName() + "{name='" + name + "', hp=" + hp + "}";
    }
}

Superclass original = new Superclass("Hero", 100);
Superclass cloned = original.clone(); // 实际上 cloned == original
original.setHp(50);
// 此时 cloned.getHp() 也会变成 50，因为它们是同一个对象

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class MyCloneableClass implements Cloneable {
    private String name;
    private int value;
    private List<String> items; // 可变引用类型字段

    public MyCloneableClass(String name, int value, List<String> items) {
        this.name = name;
        this.value = value;
        this.items = new ArrayList<>(items); // 构造器中也应防御性复制
    }

    public String getName() { return name; }
    public int getValue() { return value; }
    public List<String> getItems() { return new ArrayList<>(items); } // 返回副本以防止外部修改

    @Override
    protected Object clone() throws CloneNotSupportedException {
        MyCloneableClass cloned = (MyCloneableClass) super.clone(); // 浅克隆
        // 对可变引用类型字段进行深克隆
        cloned.items = new ArrayList<>(this.items); // 创建一个新的ArrayList副本
        return cloned;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyCloneableClass that = (MyCloneableClass) o;
        return value == that.value &&
               Objects.equals(name, that.name) &&
               Objects.equals(items, that.items); // 集合的equals会逐个比较元素
    }

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

    @Override
    public String toString() {
        return "MyCloneableClass{" +
               "name='" + name + '\'' +
               ", value=" + value +
               ", items=" + items +
               '}';
    }

    public static void main(String[] args) {
        List<String> originalItems = new ArrayList<>();
        originalItems.add("ItemA");
        MyCloneableClass original = new MyCloneableClass("Test", 10, originalItems);

        try {
            MyCloneableClass cloned = (MyCloneableClass) original.clone();
            System.out.println("Original: " + original); // Original: MyCloneableClass{name='Test', value=10, items=[ItemA]}
            System.out.println("Cloned: " + cloned);     // Cloned: MyCloneableClass{name='Test', value=10, items=[ItemA]}
            System.out.println("Are they same object reference? " + (original == cloned)); // false

            // 修改原始对象的字段
            original.getItems().add("ItemB"); // 外部获取到的items是副本，不会影响原始对象
            // 如果内部字段直接暴露，修改会影响
            // originalItems.add("ItemB"); // 这会影响原始对象的items字段，因为构造器中做了防御性复制

            System.out.println("After modifying original's items:");
            System.out.println("Original: " + original); // Original: MyCloneableClass{name='Test', value=10, items=[ItemA, ItemB]}
            System.out.println("Cloned: " + cloned);     // Cloned: MyCloneableClass{name='Test', value=10, items=[ItemA]} (深克隆成功)

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}