Java核心技术1-Object类

摘要: 本文是《Java核心技术 10th》中 Object 类的要点总结

【对算法，数学，计算机感兴趣的同学，欢迎关注我哈，阅读更多原创文章】
我的网站：潮汐朝夕的生活实验室
我的公众号：算法题刷刷
我的知乎：潮汐朝夕
我的github：FennelDumplings
我的leetcode：FennelDumplings

---

本文是《Java核心技术1》第10版 【Chap5 继承】中关于 Object 类的要点总结。由于此前在 C++ 中已经接触过面向对象编程，这里主要关注 Java 与 C++ 有区别的地方。

---

Object 所有类的超类

如果没有明确地指出超类，Object 就被认为是这个类的超类。在 Object 中有几个只在处理线程时才会被调用的方法，具体参考线程的内容。

可以用 Object 类型的变量引用任何类型的对象，Java 中只有基本类型不是对象。Object 类型的变量只能用于作为各种值的通用持有者。要想对其中的内容进行具体的操作，还需要清楚对象的原始类型，并进行相应的类型转换。

Object obj = new Employee("Harry Hacker", 35000);
Employee e = (Employee) obj;

C++ 和 Java 中关于 Object 类的区别：

在 C++ 中没有所有类的根类，不过，每个指针都可以转换成 void* 指针。

Equals 方法、相等测试与继承

Object.equals 方法用于检测一个对象是否等于另一个对象，具体是判断两个对象是否具有相同的引用。

对于具体的类如何判断相等，最好自己定义，以 Employee 为例

public class Employee {
    public boolean equals(Object otherObject) {
        // 判断两个对象是否是同一个对象
        if(this == otherObject)
            return true;

        // 判断 otherObject 是否为空
        if(otherObject == null)
            return false;

        // 判断类型是否匹配
        if(getClass() != otherObject.getClass())
            return false;

        // 此时 otherObject 是一个非空的 Employee 类对象
        Employee other = (Employee) otherObject;

        // this 和 otherObject 的各个域是否有相同值
        return Object.equals(name, other.name) // String 的 equals
            && salary == other.salary // 基本类型不是 Object 类
            && Object.equals(hireDay, other.hireDay) // LocalDate 的 equals
    }
}

getClass 方法返回对象所属的类，只有两个对象属于同一个类，才可能相等。

name 和 hireDay 不是基本类型，因此可能为 null。需要使用 Object.equals 方法。

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

子类中定义 equals 时，首先调用超类的 equals。

public class Manager extends Employee {
    public boolean equals(Object otherObject) {
        if(!super.equals(otherObject))
            return false;
        Manager other = (Manager) otherObject;
        return bunus == other.bonus;
    }
}

相等的特性

Java 语言规范要求 equals 满足以下特性

• 自反性: 对任何非空引用 x，x.equals(x) 应该返回 true。
• 对称性: 对于任何引用 x 和 y，当且仅当 y.equals(x) 返回 true，x.equals(y) 返回 true。
• 传递性: 对于任意引用 x, y, z，如果 x.equals(y), y.equals(z) 为 true，则 x.equals(z) 也为 true。
• 一致性: 如果 x, y 引用的对象没有发生变化，x.equals(y) 始终返回相同结果。
• 对于任意非空引用 x，x.equals(null) 返回 false。

getClass 与 instanceof 的适用场景

自己实现 equals 时，隐式和显式参数不属于同一个类给如何处理是主要的问题。前面的做法是如果发现类不匹配，就返回 false，例如前面的 Employee 中的 getClass() 的判断。

if(getClass() != otherObject.getClass())
    return false;

除了 otherObject.getClass() 之外，还有 instanceof 的方法，如下

if(!(otherObject instanceof Employee))
    return false;

但是注意，instanceof 没有解决 otherObject 是子类的情况，并且还会引发不满足相等的对称性特性的情况。

适合 getClass 的场景

下面我们看一下 Employee.equals 用 instanceof 检测的话如何会违反对称性。

考虑 e.equals(m)，e 是 Employee，m 是 Manager，它们的各个域的值都一样。

如果用 m instanceof Employee，则返回 true，m.equals(e) 时，e instanceof Manager 为 false，违背对称性，抛出异常。

适合 instanceof 的场景

但是也有时，我们认为不应该用 getClass 检测，因为不符合置换原则(只要父类出现的地方子类就能够出现，而且替换为子类不会产生任何错误或异常。但是反过来，子类出现的地方，替换为父类就可能出现问题了)。

例如 AbstractSet 类的 equals 方法，它检测两个集合是否有相同的元素。它们分别使用不同的算法实现查找集合元素的操作。无论集合采用何种方式实现，都需要拥有对任意两个集合进行比较的功能。

AbstractSet 有两个子类：TreeSet 和 HashSet。也就是一个 TreeSet 实例与一个 HashSet 实例是可以相等的，此时用 instanceof 更合理。这里比较特殊，因为没有任何一个子类要重新定义集合是否相等，AbstractSet.equals 应该声明为 final，但 AbstractSet.equals 并没有声明 final，这样子类可以选择更有效的算法对集合检测是否相等。

总结

• 如果子类能够拥有自己的相等概念(例如 Manager)，则对称性要求必须用 getClass 检测。
• 如果由超类决定相等的概念，那么可以在超类中用 instanceof 进行检测，这样可以在不同子类的对象之间进行相等的比较。

Java 标准库中包含 150 多个 equals 实现，包括用 instanceof 检测、用 getClass 检测、捕获 ClassCastException 或什么也不做。

自己实现 equals 的建议

• 显式参数命名为 otherObject，稍后需要将它转换成另一个叫做 other 的变量。
• 检测 this 与 otherObject 是否引用同一个对象。

  if(this == otherObject)
      return true;

• 检测 otherObject 是否为 null，若为 null 返回 false。

  if(otherObject == null)
      return false;

• 比较 this 与 otherObject 是否属于同一类。
  如果 equals 的语义在某个子类中有改变，则使用 getClass 检测：

  if(getClass() != otherObject.getClass())
      return false;

  如果所有 equals 都有统一的语义，则使用 instanceof 检测：

  if(!(otherObject instanceof ClassName))
      return false;

• 将 otherObject 转换为相应的类类型变量。

  ClassName other = (ClassName) otherObject;

• 对需要比较的域进行比较，用 == 比较基本类型域，用 equals 比较对象域。

如果在子类中重新定义 equals，则要包含 super.equals(other)。且最好加 @override 标记。

public class Employee {
    @override
    public boolean equals(Object other) {
        ...
    }
}

注意形参类型应该为 Object，如果不是，则加了 @override 后会报错，因为没有覆盖超类 Object 超类的任何方法。

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

static Boolean equals(type[] a, type[] b)

如果长度相同且对应位置元素也相同就返回 true，元素类型可以是 Object, int, long, short, char, byte, boolean, float, double。

hashCode 方法

String 类使用下列算法计算散列码。

int hash = 0;
for(int i = 9; i <  length(); ++i) {
    hash = 31 * hash + charAt(i);
}

hashCode 方法定义在 Object 类中，默认的散列吗是对象的存储地址。

关于默认散列码，下面是一个 String 和 StringBuilder 对比的例子。

public class StringTest {
    public static void main(String[] args) {
        String s = "OK";
        StringBuilder sb = new StringBuilder(s);
        System.out.println(s.hashCode() + " " + sb.hashCode());
        String t = new String("OK");
        StringBuilder tb = new StringBuilder(t);
        System.out.println(t.hashCode() + " " + tb.hashCode());
    }
}

结果如下

2524 225534817
2524 664740647

可以看到 s, t 的散列码一样，因为 String 定义了 hashCode 方法，是从内容算的散列码。

而 sb 和 tb 的散列码不一样，因为 StringBuilder 没有定义 hashCode 方法，其散列码是 Object 类的默认 hashCode 也就是对象地址。

如果要把对象插入到散列表，那么如果重新定义 equals 方法，就必须重新定义 hashCode 方法。

自己的类中实现 HashCode

在自己的类中实现 hashCode 方法应该返回一个整型数值(也可以是负数)，注意合理组合实例域的散列码，让不同对象的散列码更均匀。下面是一些常见写法

基本写法如下

public class Employee {
    public int hashCode() {
        return 7 * name.hashCode()
            + 11 * new Double(salary).hashCode()
            + 13 * hireDay.hashCode();
    }
}

还可以优化

1. 用 null 安全的 Objects.hashCode()，如果参数为 null 返回 0，否则返回对参数调用 hashCode() 的结果。
2. new Double(salary).hashCode() 可以改为用静态方法避免创建 Double 对象 Double.hashCode(salary)。

import java.util.Objects

public class Employee {
    public int hashCode() {
        return 7 * Objects.hashCode(name)
            + 11 * new Double(salary).hashCode()
            + 13 * Objects.hashCode(hireDay);
    }
}

需要组合多个散列值时，还可以调用 Objects.hash 并提供多个参数。这个方法会对各个参数调用 Objects.hashCode，并组合这些散列值。

public class Employee {
    public int hashCode() {
        return Objects.hash(name, salary, hireDay);
    }
}

equals 与 hashCode 的一致性: 如果 x.equals(y) 为 true，则 x.hashCode() 和 y.hashCode() 必须有相同的值。

如果有数组类型的域，可以用 Arrays.hashCode 方法算一个散列码，由数组元素的散列码组成。

toString 方法

绝大多数（但不是全部）的 toString 方法都遵循这样的格式：类的名字，随后是一对方括号括起来的域值。

public class Employee {
    public String toString() {
        return getClass().getName()
            + "[name=" + name
            + ",Salary=" + salary
            + ",hireDay=" + hireDay
            + "]";
    }
}

toString 也可以供子类调用。不过子类也可以定义自己的 toString。

public class Manager extends Employee {
    public String toString() {
        return super.toString()
            + "[bonus=" + bonus
            + "]";
    }
}

定义了 toString 后，只要对象与一个字符串通过操作符 “+” 连接起来，Java 编译就会自动地调用 toString 方法，以便获得这个对象的字符串描述。

“” + x 可以用于代替 x.toString()，如果 x 是基本类型，”” + x 也是可以执行的。

println(x) 会直接调用 x.toString()。

Object 定义的 toString 方法输出对象所属类名和散列码。例如：

System.out.println(System.out);

PringStream 类没有设计 toString 方法，上面输出的就是类名+散列码。

java.io.PrintStream@6e8cf4c6

数组继承了 Object 类的 toString 方法，数组类型将按照类名+散列码打印。

int[] nums = {2, 3, 4};
String s = "" + nums;
System.out.println(s);

结果如下，其中 [I 表示是整型数组。

[I@12edcd21

应该用静态方法 Arrays.toString：

String s = Arrays.toString(nums);

打印多维数组的方法 Arrays.deepToString()。

---