强制类重写 .equals 方法

Question

我有一群实现通用接口的类：Command。

这群类转到 Map 。

为了让 Map 正常工作，我需要每个实现 Command 的类重写 Object.equals(Object other) 方法。

没关系。

但我想强制平等凌驾于一切之上。 =>当执行命令的内容不覆盖 equals 时，会出现编译错误。

这可能吗？

编辑：顺便说一句，我还需要强制覆盖哈希码......

Answer 1

不，你不能。但是，您可以做的是使用抽象基类而不是接口，并使 equals() 抽象：

abstract class Command {
   // put other methods from Command interface here

   public abstract boolean equals(Object other);
   public abstract int hashCode();
}

Command 的子类必须然后提供自己的 equals 和 hashCode 方法。

强制 API 用户扩展基类通常是不好的做法，但在这种情况下可能是合理的。另外，如果您将 Command 设为抽象基类而不是接口，而不是在 Command 接口的基础上引入人工基类，那么您的 API 就不存在风险用户弄错了。

Answer 2

您可以从抽象 XObject 而不是 java.lang.Object 扩展对象吗？

public abstract class XObject
 extends Object
{
@Override
public abstract boolean equals(Object o);
}

Answer 3

如果您有孙子，抽象类将无法工作，因为它的父亲已经重写了 equals 和 hashCode 方法，然后您的问题又会出现。

尝试使用注释和 APT (http://docs.oracle .com/javase/1.5.0/docs/guide/apt/GettingStarted.html）来完成它。

Answer 4

仅当 Command 是接口或抽象类时才可能实现，其中 equals(..) 是声明为抽象的方法。

问题在于，作为所有对象的超类的 Object 已经定义了此方法。

如果您希望表明这是一个问题（在运行时），您可以抛出异常，以强制 API 的用户覆盖它。但至少据我所知，在编译时这是不可能的。

尝试通过使用特定于 API 的方法（例如 CommandEquals）来解决这个问题。另一个选项是（如上所述）扩展另一个定义 Equals 抽象方法的类。

Answer 5

您可以在interface Command中创建boolean myEquals()，并像这样创建适配器：

class MyAdapter{
  Command c;
  boolean equals(Object x) {
    return c.myEquals((Command)x);
  }
}

然后您只需使用map.put(key, new MyAdapter(command)) 而不是 map.put(key, command)

Answer 6

如果您想要运行时检查，您可以执行以下操作：

    interface Foo{

}
class A implements Foo {

}
class B implements Foo {
    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
}

public static void main(String[] args) {
    Class<A> clazzA = A.class;
    Class<B> clazzB = B.class;

    Class<Object> objectClass = Object.class;
    try {
        Method methodFromObject = objectClass.getMethod("equals",Object.class);
        Method methodFromA = clazzA.getMethod("equals",Object.class);
        Method methodFromB = clazzB.getMethod("equals",Object.class);
        System.out.println("Object == A" + methodFromObject.equals(methodFromA));
        System.out.println("Object == B" + methodFromObject.equals(methodFromB));
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
}

将为第一个打印 true，为第二个打印 false。
如果您希望编译时看起来唯一的选择是创建注释并使用注释处理工具来检查所有带注释的类是否覆盖 equals。

Answer 7

interface A{
    public boolean equal2(Object obj);
}

abstract class B implements A {

    @Override
    public boolean equals(Object obj) {
        return equal2(obj);
    }

}


class C extends B {

    public boolean equal2(Object obj) {
        throw new UnsupportedOperationException("Not supported yet.");
    }
}

Answer 8

由于 equals() 是从 Object 继承的，我怀疑你不能真正强制这样做，因为对于每个类型都有一个自动继承的实现equals() 可用。

Answer 9

我认为不可能强制覆盖 equals，因为它来自 Object 类。

在相关说明中，请注意，当您重写 equals 时，您需要重写 Object 类中的“hashCode”方法。如果您打算使用类的实例作为 Map 的键，这一点就变得特别重要。检查这篇文章：
http://www.artima.com/lejava/articles/equality.html
它提供了一些关于如何以正确的方式覆盖 equals 的提示

Answer 10

正如其他答案已经解释的那样，不，你不能强迫你想要做的事情。

可能“足够”工作的一件事是定义第二个接口，将其称为 MappableCommand。

public interface MappableCommand 
{

}

在该接口的文档中指出，如果类设计者考虑了您所说的要求，则类应该仅实现此（空）接口。

然后，您可以将地图的 Value 类型设置为 MappableCommand，并且只有 MappableCommands 才能添加到地图中。

这类似于为什么需要为可以通过 Java 的默认序列化机制序列化的类实现（空白）接口 Serialized 的逻辑。

如果这不起作用，那么您可能不得不抛出运行时错误；

假编辑：

如果您想让这个要求更加明显，您可以这样定义新界面

public interface MappableCommand 
{

    public void iOverrodeTheEqualsMethod();

    public void seriouslyIPromiseThatIOverrodeIt();

}

Answer 11

以下是其他一些建议解决方案的变体：

public abstract class CommandOverridingEquals implements Command {
    public abstract boolean equals(Object other);
    public abstract int hashcode();
}

Map<String, CommandOverridingEquals> map = 
    new HashMap<String, CommandOverridingEquals>();

或者，如果您确实想确定，请使用经过检查的哈希图；例如，

Map<String, CommandOverridingEquals> map = Collections.checkedMap(
    new HashMap<String, Command>(),
    String.class, CommandOverridingEquals.class);

但无论你做什么，你都无法阻止某人这样做：

public class AntiFascistCommand extends CommandOverridingEquals {
    public boolean equals(Object other) { return super.equals(other); }
    public int hashcode() { return super.hashcode(); }
    ...
}

我倾向于认为这种事情会在以后造成麻烦。例如，假设我有一堆现有的命令类，它们扩展了其他一些基类，并且（顺便说一句）以规定的方式覆盖equals和hashcode。问题是，我无法使用这些课程。相反，我被迫重新实现它们或编写一堆包装器。

在我看来，试图强迫开发人员采用特定的实现模式是一个坏主意。最好在 Javadoc 中加入一些强烈的警告，并依赖开发人员做正确的事情。

Answer 12

您是否可以为相关地图提供您自己的 java.util.comparator ？