Object 类

Object 类是 Java 中所有类的始祖，在 Java 中每个类都是由它扩展而来的。但是并不需要这样写：public class Employee extends Object 如果没有明确地指出父类，Object 就被认为是这个类的父类。

所有的数组类型，不管是对象数组还是基本类型的数组都扩展了 Object 类。

Employee[] staff = new Employee[10];
obj = staff; // OK
obj = new int[10]; // OK

equals() 方法

Object 类中的 equals() 方法用于检测一个对象是否等于另外一个对象。在 Object 类中，equals() 方法将判断两个对象是否具有相同的引用。然而，我们经常需要检测两个对象状态的相等性，如果两个对象的状态相等，就认为这两个对象 是相等的。

为了防备 a、b 变量可能为 null 的情况，需要使用 Objects.equals() 方法。

• 如果两个参数都为 null，Objects.equals(a, b) 调用将返回 true；
• 如果其中一个参数为 null，Objects.equals(a, b) 调用将返回 false；
• 如果两个参数都不为 null，则调用 a.equals(b)。

Java 语言规范要求 equals() 方法具有下面的特性：

• 自反性：对于任何非空引用 x，x.equals(x) 应该返回 true。
• 对称性：对于任何引用 x 和 y，当且仅当 y.equals(x) 返回 true，x.equals(y) 也应该返回 true。
• 传递性：对于任何引用 x、y 和 z，如果 x.equals(y) 返后 true，y.equals(z) 返回 true，x.equals(z) 也应该返回 true。
• 一致性：如果 x 和 y 引用的对象没有发生变化，反复调用 x.equals(y) 应该返回同样的结果。
• 对于任意非空引用 x，x.equals(null) 应该返回 false。

这些规则十分合乎情理，从而避免了类库实现者在数据结构中定位一个元素时还要考虑调用 x.equals(y)，还是调用 y.equals(x) 的问题。

相等测试

下面给出编写一个完美的 equals() 方法的建议：

1. 显式参数命名为 otherObject，稍后需要将它转换成另一个叫做 other 的变量。
2. 检测 this 与 otherObject 是否引用同一个对象：if (this == otherObject) return true;这条语句只是一个优化。实际上，这是一种经常采用的形式。因为计算这个等式要比一个一个地比较类中的域所付出的代价小得多。
3. 检测 otherObject 是否为 null，如果为 null，返回 false。if (otherObject = null) return false;这项检测是很必要的，避免后面判断 otherObject 的实例域时出现 NullPointerException 异常。
4. 比较 this 与 otherObject 是否属于同一个类：
   • 如果 equals 的语义在每个子类中有所改变，就使用 getClass 检测：if (getClass() != otherObject.getClass()) return false;
   • 如果所有的子类都拥有统一的语义，就使用 instanceof 检测：if (!(otherObject instanceof ClassName)) return false;
5. 将 otherObject 转换为相应的类的类型变量：ClassName other = (ClassName) otherObject;
6. 现在开始对所有需要比较的域进行比较了。使用 == 比较基本类型域，使用 equals() 方法比较对象域。如果所有的域都匹配，就返回 true；否则返回 false。return fieldl == other.field && Objects.equa1s(fie1d2, other.field2)

如果在子类中重新定义 equals() 方法，就要在其中调用父类的 equals() 方法 super.equals(other)。如果检测失败，对象就不可能相等。如果父类中的域都相等，就需要比较子类中的实例域。

提示：对于数组类型的域，可以使用静态的 Arrays.equals() 方法检测相应的数组元素是否相等。

// String 类的 equals() 方法
public boolean equals(Object anObject) {
    // 检测 this 与 anObject 是否引用同一个对象
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        // 将 otherObject 转换为相应的类的类型变量
        String anotherString = (String) anObject;
        // 对所有需要比较的域进行比较
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

hashCode() 方法

如果重新定义 equals() 方法，就必须重新定义 hashCode() 方法，以便用户可以将对象插入到散列表（Map 集合）中。

equals() 与 hashCode() 的定义必须一致：如果 x.equals(y) 返回 true，那么 x.hashCode() 就必须与 y.hashCode() 具有相同的值。例如，如果用定义的 Employee.equals() 比较雇员的 ID，那么 hashCode() 方法就需要散列 ID，而不是雇员的姓名或存储地址。

提示：如果存在数组类型的域，那么可以使用静态的 Arrays.hashCode() 方法计算一个散列码，这个散列码由数组元素的散列码组成。

// String 类的 hashCode() 方法
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

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

toString() 方法

在 Object 类中还有一个重要的方法，就是 toString() 方法，它用于返回表示对象值的字符串。

随处可见 toString() 方法的主要原因是：只要对象与一个字符串通过 “+” 操作符连接起来，Java 编译就会自动地调用 toString() 方法，以便获得这个对象的字符串描述。

// java 文件
public static void main(String[] args) {
    P p = new P();
    String s = "p =" + p;
}

// class 文件
public static void main(String[] args) {
    P p = new P();
    String s = "p =" + String.valueOf(p);
}

如果 x 是任意一个对象， 并调用 System.out.println(x); println() 方法就会直接地调用 x.toString()，并打印输出得到的字符串。

Object 类定义了 toString() 方法，用来打印输出对象所属的类名和散列码。例如，调用 System.out.println(System.out) 将输出下列内容：java.io.PrintStream@2f6684。

要想打印数组，调用静态方法 Arrays.toString() 方法。要想打印多维数组（即，数组的数组）则需要调用 Arrays.deepToString() 方法。

// Object 类的 toString() 方法
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

参考资料

《Java核心技术卷一：基础知识》（第10版）第 5 章：继承 5.2 Object：所有类的超类