问题来源

来自《Java核心技术卷Ⅰ》（11版）中P177。

不过，集合是非常特殊的一个例子，应该将AbstractSet.equals声明为final,这是因为没有任何一个子类需要重新定义集合相等的语义（事实上，这个方法并没有被声明为final。这样做是为了让子类实现更高效的算法来完成相等性检测)。 就现在来看，有两种完全不同的情形：

  • 如果子类可以有自己的相等性概念，则对称性需求将强制使用getClass检测。

  • 如果由超类决定相等性概念，那么就可以使用instanceof检测，这样可以在不同子类 的对象之间进行相等性比较

没有设计成final的解析

  • 集合相等性语义统一：集合的相等性由元素内容决定（元素相同且顺序无关），与具体实现类无关。例如：
1
2
3
4
5

```java
Set<String> hashSet = new HashSet<>(List.of("A", "B"));
Set<String> treeSet = new TreeSet<>(List.of("B", "A"));
System.out.println(hashSet.equals(treeSet)); // true（元素内容相同）
  • 允许子类优化算法：虽然语义统一，但不同集合实现（如HashSet和TreeSet）可能通过优化算法提升比较效率。例如：
    • 先比较size()快速失败。
    • 利用哈希值预筛选（如HashSet内部实现）。
  • 未声明final的权衡：保持方法可重写性，允许子类实现更高效的比较逻辑，但不改变语义。

两种继承场景下的equals设计策略

场景特征 类型检测方式 典型应用案例 风险控制
子类扩展影响相等性逻辑 getClass() 员工与经理类继承体系 避免对称性/传递性破坏
超类完全定义相等性语义 instanceof 不可变类、集合类 需确保子类不添加关键状态字段

(1) 子类有独立相等性概念 → 强制使用getClass()

适用场景：子类添加了影响相等性判断的新状态。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Employee {
    private String id;
    // equals使用getClass()检测
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee e = (Employee) o;
        return Objects.equals(id, e.id);
    }
}

class Manager extends Employee {
    private double bonus; // 新增影响相等性的字段
    // 必须重写equals，且使用getClass()
    public boolean equals(Object o) {
        if (!super.equals(o)) return false;
        Manager m = (Manager) o;
        return Double.compare(m.bonus, bonus) == 0;
    }
}

关键约束：确保对称性（a.equals(b) == b.equals(a)），避免父类与子类实例误判相等。

(2) 超类统一控制相等性 → 使用instanceof

适用场景：所有子类的相等性由超类字段完全决定，子类无新增状态或状态不影响相等性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class ImmutablePoint {
    private final int x, y;
    // 使用instanceof允许子类实例参与比较
    public boolean equals(Object o) {
        if (!(o instanceof ImmutablePoint)) return false;
        ImmutablePoint p = (ImmutablePoint) o;
        return x == p.x && y == p.y;
    }
}

// 子类不添加新字段，或新字段不影响相等性
class NamedPoint extends ImmutablePoint {
    private String name; // 不参与相等性判断
    // 无需重写equals
}

优势：支持跨子类比较，符合逻辑相等性（如数学上的点坐标相同即相等）。

最佳实践总结

  • 优先组合而非继承：若子类需要独立相等性逻辑，考虑使用组合而非继承。

    • 组合例子：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      class Employee {
          private String id;
          // 不涉及继承的独立equals逻辑
      }

      class Manager {
          private Employee employee;  // 组合代替继承
          private double bonus;
          
          public boolean equals(Object o) {
              if (this == o) return true;
              if (!(o instanceof Manager)) return false;
              Manager m = (Manager) o;
              return employee.equals(m.employee) &&  // 委托比较
                     bonus == m.bonus;
          }
      }

  • 严格契约优先：默认使用getClass()，除非明确需要跨子类相等性。

  • 不可变类特例：若类为final或状态不可变，instanceof是安全选择。

1
2
3
4
5
6
7
8
// 安全使用instanceof的不可变类示例
public final class ImmutableDate {
    private final long timestamp;
    public boolean equals(Object o) {
        if (!(o instanceof ImmutableDate)) return false;
        return ((ImmutableDate) o).timestamp == timestamp;
    }
}

通过这种设计策略，可以在灵活性和契约安全性之间找到平衡点。