理解equals方法

Question

J。 Bloch 在其有效的 Java 中为 equals 方法的实现提供了几个规则。他们在这里：

• 自反：对于任何非空引用值 x，x.equals(x) 必须 返回真。

• 对称：对于任何非空引用值 x 和 y， x.equals(y) 必须返回 true 当且仅当 y.equals(x) 返回 true。

• 传递：对于任何非空引用值 x、y、z，如果 x.equals(y) 返回 true 并且 y.equals(z) 返回 true，然后 x.equals(z) 必须返回 true。

• 一致：对于任何非空引用 值 x 和 y，x.equals(y) 的多次调用一致 如果未使用任何信息，则返回 true 或始终返回 false in equals 对对象的比较进行了修改。

• 对于任何非空 参考值 x, x.equals(null) 必须返回 false。

但后来他在书中提到了所谓的里氏替换原则：

Liskov 替换原则说，任何重要的属性 一个类型也应该适用于它的子类型，这样任何编写的方法 因为该类型应该同样适用于其子类型

我看不出它与equals 合同有何联系。在编写 equals 实现时，我们真的应该遵守它吗？

问题是关于实现子类的方法。这是书中的例子：

private static final Set<Point> unitCircle;

static {
    unitCircle = new HashSet<Point>();
    unitCircle.add(new Point(1, 0));
    unitCircle.add(new Point(0, 1));
    unitCircle.add(new Point(-1, 0));
    unitCircle.add(new Point(0, -1));
}

public static boolean onUnitCircle(Point p) {
    return unitCircle.contains(p);
}

public class CounterPoint extends Point {
    private static final AtomicInteger counter = new AtomicInteger();

    public CounterPoint(int x, int y) {
        super(x, y);
        counter.incrementAndGet();
    }

    public int numberCreated() { return counter.get(); }
}

以及以下实现：

// Broken - violates Liskov substitution principle (page 40)
@Override public boolean equals(Object o) {
    if (o == null || o.getClass() != getClass())
        return false;
    Point p = (Point) o;
    return p.x == x && p.y == y;
}

好的，违反了，然后呢？我不明白。

Answer 1

通常有两种方法可以在equals方法中检查类型：

选项 1：instanceof

if (! (obj instanceof ThisClass)){
    return false;
}

此选项尊重Liskov 替换原则。但是您不能在子类中添加与 equals 方法相关的其他属性，而不会破坏等价关系的特征（自反、对称、传递）。

选项 2：getClass()

if (obj == null || ! this.getClass().equals(obj.getClass())) {
    return false;
}

此选项违反Liskov 替换原则。但是您可以在子类中添加与 equals 方法相关的附加属性，而不会破坏等价关系的特征（自反、对称、传递）。

Joshua Bloch 在他的《Effective Java》一书中对此提出了警告。

Angelika Langer 提到了一种“混合类型”比较的方法，如果您可以为其他属性定义默认值：

http://www.angelikalanger.com/Articles/JavaSolutions/SecretsOfEquals/Equals-2.html

缺点是equals方法变得相当复杂。

// Broken - violates Liskov substitution principle (page 40)
@Override public boolean equals(Object o) {
    if (o == null || o.getClass() != getClass())
        return false;
    Point p = (Point) o;
    return p.x == x && p.y == y;
}

好的，违反了，然后呢？我不明白。

因此，如果您有一个子类，例如 MyPoint（可能会添加其他方法，但不会添加其他属性/字段），那么

Point p1 = new Point(x, y);
Point p2 = new MyPoint(x, y);

p1.equals(p2) == false

Set<Point> points = new HashSet<>();
points.add(p1);

points.contains(p2) == false;

虽然这两个对象确实代表同一个点。

如果您改用选项 1 (instanceof)，equals 方法将返回 true。

Answer 2

我想他是想说一个点的特征是它的坐标。所以你会认为这是真的：

new Point(0, 0).equals(new CounterPoint(0, 0));

因为这两个点的坐标相同，即使它们的类型不同。但是建议的 equals 方法会返回 false，因为这两个对象有不同的类。

如果您以集合为例，这是正确的：

new LinkedList().equals(new ArrayList());

这两个列表的类型不同，但它们的内容相同（在这种情况下，它们都是空的），因此被认为是相等的。