我有一个简单的基类，后来被许多单独的类扩展，这些类可能会引入新字段，但不一定。我在基类中定义了一个 equals 方法，但也为一些子类覆盖了它。可以在基类/子类中混合定义吗？就我而言，这是为了避免代码重复检查相同的字段。
【问题讨论】：
我认为只要遵守eqauls() 和hashcode() 合同就可以了。
【讨论】：
您可以使用super() 方法来调用您正在扩展的类的方法，以防止任何代码重复
public class BaseClass {
public boolean equals(BaseClass other) {
return (other.getBlahblah() == this.Blahblah && .....);
}
}
public class DerivedClass extends BaseClass {
public boolean equals(DerivedClass other) {
return (super(other) && other.getNewAttribute() == this.NewAttribute.....);
}
}
【讨论】：
相当有效的方法。问题在于您的其中一个子类必须保留受其父级约束的 equals 定义。否则你有一个损坏的 equals 函数，这可能会在运行时导致一些非常独特的场景。
【讨论】：
不，在引入与 equals 方法相关的新字段时，不可能符合 equals 约定。有关详细信息，请参阅 Joshua Bloch 的“Effective Java”。
编辑：
我现在手头没有这本书，但我认为如果基类是抽象的/无法实例化就可以了。
【讨论】：
我想，在super class 中提供equals(Object obj) 和hashCode() 方法实现就像Java 一样完美。我们都知道，Java 在基类java.lang.Object 中提供了hashCode() and equals(Object obj) 方法实现，并且当需要时，我们在class 中提供override 它们。
【讨论】：
看看来自 Angelika Langer 的"Implementing equals() To Allow Mixed-Type Comparison"。
以下是一些问题的简要说明和可能的解决方案：
平等合同说（其中包括）：
它是对称的：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应该返回 true。
这意味着如果您的子类引入新字段并且您将基类的对象（或另一个不覆盖 equals 的子类）与该子类的对象进行比较，您可能会遇到问题。
请勿执行以下操作：
class BaseClass {
private int field1 = 0;
@Override
public boolean equals(Object obj) {
if (obj instanceof BaseClass) {
return field1 == ((BaseClass) obj).field1;
}
return false;
}
}
class BadSubClass extends BaseClass {
private int field2 = 0;
@Override
public boolean equals(Object obj) {
if (obj instanceof BadSubClass) {
return super.equals(obj)
&& field2 == ((BadSubClass) obj).field2;
}
return false;
}
}
因为你得到
BaseClass baseClass = new BaseClass();
BadSubClass subClass = new BadSubClass();
System.out.println(baseClass.equals(subClass)); // prints 'true'
System.out.println(subClass.equals(baseClass)); // prints 'false'
一种可能的解决方案：
将instanceof-check 替换为类比较：
obj != null && obj.getClass() == getClass()
使用此解决方案，BaseClass 的对象永远不会等于任何子类的对象。
如果您在没有 equals 方法的 @Override 的情况下创建另一个 SubClass，则两个 SubClass-objects 可以彼此相等（如果 BaseClass.equals 检查决定如此）开箱即用，但是SubClass-object 永远不会等于 BaseClass-object。
一个好的实现可能如下：
class BaseClass {
private int field1 = 0;
@Override
public boolean equals(Object obj) {
if (obj != null && obj.getClass() == getClass()) {
return field1 == ((BaseClass) obj).field1;
}
return false;
}
}
class GoodSubClass extends BaseClass {
private int field2 = 0;
@Override
public boolean equals(Object obj) {
if (obj instanceof GoodSubClass) {
return super.equals(obj) && field2 == ((GoodSubClass) obj).field2;
}
return false;
}
}
有关更高级的问题及其解决方案，请参阅上述文章。
【讨论】：
super.equals()。我刚刚提交了相应的编辑
GoodSubClass的equals()中，我们需要检查obj instanceof GoodSubClass吗？ super.equals(obj) 不是已经报道了吗？
虽然以下内容不能处理所有情况，但我发现它非常实用。当我同时使用 SuperClass 和 SubClass 时，我已经使用过很多次了。我不想相互比较它们，但我也不想为 SubClass 重新实现所有 SuperClass equals()。它处理：
代码示例
// implement both strict and asymmetric equality
class SuperClass {
public int f1;
public boolean looseEquals(Object o) {
if (!(o instanceof SuperClass)) return false;
SuperClass other = (SuperClass)o;
return f1 == other.f1;
}
@Override public boolean equals(Object o) {
return looseEquals(o) && this.getClass() == o.getClass();
}
}
class SubClass extends SuperClass {
public int f2;
@Override public boolean looseEquals(Object o) {
if (!super.looseEquals(o)) return false;
if (!(o instanceof SubClass)) return false;
SubClass other = (SubClass)o;
return f2 == other.f2;
}
// no need to override equals()
}
【讨论】：
如果您没有正确编写代码，则会产生一个严重的问题，称为 不对称（违反平等契约）所以让我们看看我们的选择。
最佳实践 – 同课策略。如果 B 是 A 的子类 每个类都有自己的equals方法，实现 使用相同的类策略，那么 B 类应该是 宣布最终以防止引入不对称 在 B 的任何未来子类中定义 equals。
问题。如果我们不想让 B 成为最终版本怎么办？
使用组合而不是继承。每当 B 类和 A，其中 B 是 A 的子类，需要不同的 equals 方法， 使用组合而不是继承是一个很好的策略，并且 如果无法选择最终 B 类，这是唯一安全的方法 处理等于。
怎么样？
public class A{
public boolean equals(Object ob){
//write your code here
}
}
class B{
A a= new A();
public B(A a){
this.a= a;
}
public boolean equals(Object ob){
//...write your code here
if(!((B)ob).a).equals(a)) return false;
//...write your code here
}
}
【讨论】：