覆盖equals需要遵守的通用约定

覆盖equals需要遵守的通用约定：
覆盖equals方法看起来似乎很简单，但是有许多覆盖方式会导致错误，并且后果非常严重。
因此在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，只要equals的比较操作在对象中所用的信息没有被修改，多次调用x.equals(y)就会一直的返回true，或者一直的返回false。
5、对于任何非null的引用值x，x.equals(null)必须返回false。
通过系列两个类验证覆盖equals方法必修要遵守的通用约定：

Point类：

public class Point {
	private final int x;
	private final int y;
	
	public Point(int x, int y) {
		this.x = x;
		this.y = y;
	}
	@Override
	public boolean equals(Object o) {
		if (!(o instanceof Point))
		return false;
		Point p = (Point) o;
		return p.x == x && p.y == y;
	}

}

继承自Point的子类ColorPoint：

public class ColorPoint extends Point {
	private final Color color;
	public ColorPoint(int x, int y, Color color) {
		super(x, y);
		this.color = color;
	}
	@Override
	public boolean equals(Object o) {
		if (!(o instanceof ColorPoint))
			return o.equals(this);
		return super.equals(o) && ((ColorPoint) o).color == color;
	}

a）自反性验证：

Point p = new Point(10,15);
ColorPoint cp = new ColorPoint(10,15,Color.BLUE);
System.out.println(p.equals(p) + " ------ "+cp.equals(cp));   //true ------ true

b) 对称性验证：

Point p = new Point(10,15);
ColorPoint cp = new ColorPoint(10,15,Color.BLUE);
System.out.println(p.equals(cp) + " ------ "+cp.equals(p));   //true ------ true

c) 传递性验证：

Point p = new Point(10,15);
ColorPoint cp = new ColorPoint(10,15,Color.BLUE);
ColorPoint cp1 = new ColorPoint(10,15,Color.RED);
System.out.println(p.equals(cp) + " ------ "+cp.equals(cp1) + "------"+p.equals(cp1));   //true------ false ------ true

通过上述验证，类Point和ColorPoint重写的equals满足自反性、对称性，但是不满足传递性，因此上述重写的equals方法存在问题；
在面向对象中，我们无法在可扩展可实例化的类时，既增加新的组件，同时又保留equals约定，解决办法是使用“复合优于继承”，不在让子类扩展父类，而是在子类中加入一个可私有的父类域和一个公有的视图方法。
代码如下：

public class ColorPoint {
  private final Point point;
  private final Color color;

  public ColorPoint(int x, int y, Color color) {
	  if (color == null)
		throw new NullPointerException();
	  point = new Point(x, y);
	  this.color = color;
  }

  public Point asPoint() {
	return point;
  }

  @Override 
  public boolean equals(Object o) {
	  if (!(o instanceof ColorPoint))
		return false;
	  ColorPoint cp = (ColorPoint) o;
	  return cp.point.equals(point) && cp.color.equals(color);
  }

  @Override 
  public int hashCode() {
	return point.hashCode() * 33 + color.hashCode();
  }
}

传递性的执行结果为：

Point p = new Point(10,15);
ColorPoint cp = new ColorPoint(10,15,Color.BLUE);
ColorPoint cp1 = new ColorPoint(10,15,Color.RED);
System.out.println(p.equals(cp) + " ------ "+cp.equals(cp1) + "------"+p.equals(cp1));   //false ------ false ------ false 

满足自反性、对称性和传递性，三者缺一不可。

在覆盖equals时总要覆盖hashCode方法：
原因：
为什么再覆盖equals方法时总要覆盖hashCode方法？
不这么做会违反hashCode的通用约定，导致该类无法结合所有基于散列的集合一起正常运作，类集合有hashMap、hashSet。
需要做逻辑相等判断的类，覆盖equals方法，如果还需要在散列表（HashMap、HashSet）中作为key，需要覆盖hashcode方法。

覆盖hashCode方法通用约定：
1、在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对同一对象的多次调用，hashCode方法都必须始终返回同一个值。在一个应用程序与另外一个应用程执行过程中，执行hsahCode方法所返回的值可以不一致。
2、如果两个对象根据equals（Object）方法比较是相等的，那么调用这两个对象中的hashCode方法都必须产生同样的整数结果。
3、如果两个对象根据equals（Object）方法比较是不相等的，那么调用这两个对象中的hashCode方法，则不一定要求hashCode方法必须产生不同的结果。但开发者应该知道，给不相等的对象产生截然不同的整数结果，有可能提高散列表的性能。
----------摘自《Effective Java》
上述通用约定的实现例如ColorPoint中的覆盖方法hashCode():

@Override 
  public int hashCode() {
	return point.hashCode() * 33 + color.hashCode();
  }

扩展-equals() + hashCode()（解析hashCode通用约定）：
1.若重写了equals(Object obj)方法，则有必要重写hashCode()方法。
2.若两个对象equals(Object obj)返回true，则hashCode（）有必要也返回相同的int数:
覆盖hashCode方法，但不覆盖equals方法，仍然会导致数据的不唯一性
3.若两个对象equals(Object obj)返回false，则hashCode（）不一定返回不同的int数:

4.若两个对象hashCode（）返回相同int数，则equals（Object obj）不一定返回true:

5.若两个对象hashCode（）返回不同int数，则equals（Object obj）一定返回false:

6.同一对象在执行期间若已经存储在集合中，则不能修改影响hashCode值的相关信息，否则会导致内存泄露问题。