Java--举例详解equals方法重写

爱被打了一巴掌 2021-08-13 16:18 490阅读 0赞

Object类中的equals方法用于检测一个对象是否等于另外一个对象。在Object类中，这个方法将**判断两个对象是否具有相同的引用**。如果两个对象具有相同的引用，它们一定是相等的。从这点看，将其作为默认操作也是合乎情理的。然而，对于多数类来说，这种判断并没有什么意义。例如，采用这种方式比较两个PrintStream对象是否相等就完全没有意义。然而，经常需要检测两个对象状态的相等性，如果两个对象的状态相等，据认为这两个对象是相等的。

#### equals方法 ####

**例如，如果两个雇员对象的姓名、薪水和雇佣日期都一样，就认为它们是相等的。**

package equals;
    
    import java.time.LocalDate;
    
    public class Employee { 
    
    	private String name;
    	private double salary;
    	private LocalDate hireDay;
    	
    	public Employee(String name, double salary, LocalDate hireDay) { 
    		super();
    		this.name = name;
    		this.salary = salary;
    		this.hireDay = hireDay;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public double getSalary() { 
    		return salary;
    	}
    
    	public void setSalary(double salary) { 
    		this.salary = salary;
    	}
    
    	public LocalDate getHireDay() { 
    		return hireDay;
    	}
    
    	public void setHireDay(LocalDate hireDay) { 
    		this.hireDay = hireDay;
    	}
    
    	@Override
    	public int hashCode() { 
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((hireDay == null) ? 0 : hireDay.hashCode());
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		long temp;
    		temp = Double.doubleToLongBits(salary);
    		result = prime * result + (int) (temp ^ (temp >>> 32));
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) { 
    		if (this == obj) //判断是否为相同引用
    			return true;
    		if (obj == null) //判断obj是否为空
    			return false;
    		if (getClass() != obj.getClass()) //判断两个对象所属的类是否相同
    			return false;
    		Employee other = (Employee) obj;
    		return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);
    	}
    	
    }

注 意 ： \\color\{red\}\{注意：\} 注意：为了防备 name 或 hireDay 可能为 null 的情况，需要使用Objects.equals方法。如果两个参数都为 null，Objects.equals(a, b) 调用将返回 true；如果其中一个参数为 null，则返回 false；否则，如果两个参数都不为 null，则调用 a.equals(b)。

**在子类中定义equals方法时，首先调用超类的equals。如果检测失败，对象就不可能相等。如果超类中的域都相等，就需要比较子类中的实例。**

package equals;
    
    import java.time.LocalDate;
    
    public class Manager extends Employee { 
    
    	public Manager(String name, double salary, LocalDate hireDay, double bonus) { 
    		super(name, salary, hireDay);
    		this.bonus = bonus;
    	}
    
    	private double bonus;
    
    	public double getBonus() { 
    		return bonus;
    	}
    
    	public void setBonus(double bonus) { 
    		this.bonus = bonus;
    	}
    
    	@Override
    	public int hashCode() { 
    		final int prime = 31;
    		int result = super.hashCode();
    		long temp;
    		temp = Double.doubleToLongBits(bonus);
    		result = prime * result + (int) (temp ^ (temp >>> 32));
    		return result;
    	}
    
    	@Override
    	public boolean equals(Object obj) { 
    		if (this == obj)
    			return true;
    		if (!super.equals(obj)) //调用超类的equals比较
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Manager other = (Manager) obj;
    		if (Double.doubleToLongBits(bonus) != Double.doubleToLongBits(other.bonus))
    			return false;
    		return true;
    	}
    }

#### 相等测试与继承 ####

如果隐式和显示的参数不属于同一个类，equals 方法将如何处理？这是一个很有争议的问题。在前面的例子中，如果发现类不匹配，equals方法就返回一个false。但是，我们许多人却喜欢使用 instanceof 进行检测：

if(!otherObject instanceof Employee)
        return false;

但 是 ， 这 样 做 不 但 没 有 解 决 o t h e r O b j e c t 是 子 类 的 情 况 ， 并 且 还 有 可 能 会 招 致 一 些 麻 烦 。 \\color\{red\}\{但是，这样做不但没有解决 otherObject 是子类的情况，并且还有可能会招致一些麻烦。\} 但是，这样做不但没有解决otherObject是子类的情况，并且还有可能会招致一些麻烦。

**Java语言规范要求equals方法应具有下面的特性：**

1.  **自反性：** 对于任何非空引用 x，x.equals(x) 应该返回true。
2.  **对称性：** 对于任何引用 x，y，当且仅当 y.equals(x) 返回 true，x.equals(y) 也应该返回 true。
3.  **传递性：** 对于任何引用 x，y 和 z，如果 x.equals(y) 返回 true，y.equals(z) 返回 true，那么 x.equals(z) 也应该返回true。
4.  **一致性：** 如果 x 和 y 引用的对象没有发生变化， 反复调用 x.equals(y) 应该返回相同的结果。
5.  **对于任意非空引用 x， x.equals(null) 应该返回 false。**

此时再考虑上面的例子：

e.equals(m)

这里的 e 是一个Employee对象， m 是一个Manager对象，并且两个对象具有相同的姓名、薪水和雇佣日期。如果在Employee.equals中用instanceof进行检测，则返回true。然而这意味着反过来调用：

m.equals(e)

也需要返回true。对称性不允许这个方法调用返回false，或者抛出异常。

这就使得Manager类收到了束缚。这个类的equals方法必须能够用自己与任何一个Employee对象进行比较，而不考虑经理（Manager）拥有的那部分特有信息！所以说instanceof测试并不是完美无瑕。

**下面可以从两个截然不同的情况看一下这个问题：**

*  如果子类能够拥有自己的相等概念，则对称性需求将强制采用 getClass 进行检测。
 *  如果由超类决定相等的概念，那么就可以使用 instanceof 进行检测， 这样可以在不同子类的对象之间进行相等的比较。

在雇员和经理的例子中，只要对应的域相等，就认为两个对象相等。如果两个Manager 对象所对应的姓名、薪水和雇佣日期均相等，而奖金不相等，就认为它们是不相同的，因此，可以使用getClass检测。  
      但是，假设使用雇员的ID作为相等的检测标准，并且这个相等的概念适用于所有的子类，就可以使用 instanceof 进行检测，并应该将 Employee.equals 声明为 final。

**综上所述，下面给出一个完美的 equals 方法的建议：**

1.  **显示参数命名为 otherObject，稍候需要将它转换为另一个叫做 other 的变量。**
2.  **检测 this 与 otherObject 是否引用同一个对象：**  
    if (this == otherObject) return true;
3.  **检测 otherObject 是否为 null，如果为 null，返回 false。 这项检测非常必要。**  
    if (otherObject == null) return false;
4.  **比较 this 与 otherObject 是否属于同一个类。**

*  如果 equals 的语义在每个子类中有所改变，就使用 getClass 检测。  
    if (getClass() != otherObjcet.getClass()) return false;
 *  如果所有的子类都有统一的语义，就是用 instanceof 检测。  
    if (!(otherObject instanceof ClassName)) return false;

1.  **将 otherObject 转换为响应的类类型变量。**  
    ClassName other = (ClassName) otherObjcet;
2.  **现在开始对所有需要比较的域进行比较。使用 == 比较基本类型域，使用 equals 比较对象域。如果所有域都匹配，就返回 true；否则返回 false。**