这篇博文主要介绍覆盖Object中的方法要注意的事项以及Comparable.compareTo()方法。
一、谨慎覆盖equals()方法
其实平时很少要用到覆盖equals方法的情况，没有什么特殊情况最好是使用原有提供的equlas方法。因为覆盖equals()方法时要遵循一些通用的约定之外，在与hash相关的集合类使用时，就必须要覆盖hashCode()方法了（第二点会强调）。
我们先说说覆盖equlas()方法要遵循哪些通用约定：
1、自反性：对于任何非null的引用值x, x.equals(x)必须返回true；
2、对称性：对于任何非null的引用值x和y，当且仅当y.equals(x)返回true时，x.equals(y)必须返回true；
3、传递性：对于任何非null的引用值x、y和z，当且仅当x.equals(y)返回true，并且y.equals(z)也返回true，那么x.equals(z)也必须返回true；
4、一致性：对于任何一个非null的引用值x和y，只要equals的比较操作在对象中所用的信息没有被修改，多次调用x.equals(y)的结果依然一致。；
5、非空性：对于任何非null的引用值，x.equals(null)必须返回false。 且x必须不能为空，否则会抛出空指针异常。
其实上面这些约定看起来都看简单但也不能大意，很有可能你只满足了其中一点或者几点没有满足全部。如果没有满足全部的话，那么你覆盖equals()方法是不合理的，总会有那么中情况会超乎你的意料之外。
下面我们举例说明，其中自反性是很难违反的（我也想象不出怎么举反例测试，如有高手明白，请举例评论下），下面我举例验证对称性：
package test.effective;
/**
* @Description: 普通坐标类
* @author yuanfy
* @date 2017年7月13日 上午10:30:06
*/
class Point {
private int x;
private int y; public Point(int x, int y) {
this.x = x;
this.y = y;
} @Override
public boolean equals(Object obj) {
if (!(obj instanceof Point)) {
return false;
}
Point p = (Point) obj;
return this.x == p.x && this.y == p.y;
}
}
/**
* @Description: 带有颜色的坐标
* @author yuanfy
* @date 2017年7月13日 上午10:35:19
*/
class ColorPoint extends Point { private String color; public ColorPoint(int x, int y, String color) {
super(x, y);
this.color = color;
}
/**
* 与point不满足对称性示范案例
*/
@Override
public boolean equals(Object obj) {
if (!(obj instanceof ColorPoint)) {
return false;//与point实例比较直接返回false
}
ColorPoint p = (ColorPoint) obj;
return super.equals(p) && this.color.equals(p.color);
}
} public class EqualsTest {
public static void main(String[] args) {
Point p = new Point(1,2);
ColorPoint cp = new ColorPoint(1, 2, "red"); System.out.println(p.equals(cp));//输出结果：true
System.out.println(cp.equals(p));//输出结果：false
}
}
从上面的例子可以看出是违反了对称性规定的。问题原因在于：在比较普通点和有色点时，忽略了颜色的比较，而有色点跟普通点比较时，普通点不属于ColorPoint的实例，就直接返回了false。所以ColorPoint类中覆盖equlas()方法是有问题的，修改equals()方法后的代码如下：
@Override
public boolean equals(Object obj) {
//不属于Point实例对象
if (!(obj instanceof Point)) {
return false;
}
//不是ColorPoint实例对象,可能是Point实例对象或者其他类型对象
if (!(obj instanceof ColorPoint)) {
return super.equals(obj);
}
//ColorPoint实例对象
ColorPoint p = (ColorPoint) obj;
return super.equals(p) && this.color.equals(p.color);
}
测试代码如下：
ColorPoint cp1 = new ColorPoint(1, 2, "red");
Point p = new Point(1,2);
ColorPoint cp2 = new ColorPoint(1, 2, "blue"); System.out.println(cp1.equals(p));//输出结果：true
System.out.println(p.equals(cp1));//输出结果：true System.out.println(p.equals(cp2));//输出结果：true
System.out.println(cp2.equals(p));//输出结果：true System.out.println(cp1.equals(p));//输出结果：true
System.out.println(p.equals(cp2));//输出结果：true
System.out.println(cp1.equals(cp2));//输出结果：false
从修改后的例子中可以看出，这种方法确实满足了对称性，但是却不满足传递性。其实我们无法在扩展可实例化的类的同时，既增加新的值组件，同时又保留equals约定，除非愿意放弃面向对象的抽象带来的优势。当然我们可以不扩展Point的，所谓“复合优先于继承”。在ColorPoint假如一个私有的Point域，代码如下：
class ColorPoint{ private String color; private Point point; public ColorPoint(int x, int y, String color) {
point = new Point(x, y);
this.color = color;
} public Point asPoint(){
return point;
} @Override
public boolean equals(Object obj) {
if (!(obj instanceof ColorPoint)) {//满足非空性验证
return false;
}
//ColorPoint实例对象
ColorPoint p = (ColorPoint) obj;
return this.point.equals(p.point) && this.color.equals(p.color);
}
} public class EqualsTest1 {
public static void main(String[] args) {
ColorPoint cp1 = new ColorPoint(1, 2, "red");
Point p = new Point(1,2);
ColorPoint cp2 = new ColorPoint(1, 2, "red");
ColorPoint cp3 = new ColorPoint(1, 2, "red"); System.out.println(cp1.equals(p));//输出结果：false
System.out.println(p.equals(cp1));//输出结果：false System.out.println(cp1.equals(cp2));//输出结果：true
System.out.println(cp2.equals(cp1));//输出结果：true System.out.println(cp1.equals(cp2));//输出结果：true
System.out.println(cp2.equals(cp3));//输出结果：true
System.out.println(cp1.equals(cp3));//输出结果：true
}
}
上面的例子就满足对称性、传递性同时满足非空性。
接下来验证一致性：如果两个对象相等，它们就必须始终保持相等，除非他们中有一个对象或者两个都被修改了。换句话说，可变的对象在不同的时候可以与不同的对象相等， 而不可变对象则不会这样。比如说时间对象一个指定了时间，另外一个对象没有指定时间。当在某一个刻时候，他们既满足对称性和传递性，但是它不满足一致性。因为没有指定时间的对象的时间是一直在改变的。
所以当你编写完成了equlas之后，应该测试验证是否满足这个几个特性。
二、覆盖equals时总要覆盖hashCode
书中提出：在每个覆盖了equlas方法的类，也必须覆盖hashCode方法。如果不这样做的话， 就会违反Object.hashCode()的通用约定，从而导致该类无法结合所有基于散列的集合一起正常运作，这样的集合包括HashMap、HashSet和HashTable。
其中约定简洁如下（详细请参考书中）：
1、相等的对象必须具有相等的散列码（hash code）
2、不相等的对象未必是不一样的散列码。也就是说相同散列码的两个对象，两个对象未必相等。但是相等的两个对象，一定就有相等的散列码。
下面根据例子来说明:
package test.effective; import java.util.HashMap;
import java.util.Map; public class PhoneNumber {
private int areaCode; private int prefix; private int lineNumer; public PhoneNumber(int areaCode, int prefix, int lineNumer) {
this.areaCode = areaCode;
this.prefix = prefix;
this.lineNumer = lineNumer;
} @Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof PhoneNumber)) {
return false;
}
PhoneNumber pn = (PhoneNumber) obj;
return this.areaCode == pn.areaCode
&& this.prefix == pn.prefix
&& this.lineNumer == this.lineNumer;
} public static void main(String[] args) { Map<PhoneNumber, String> map = new HashMap<PhoneNumber, String>();
PhoneNumber pn1 = new PhoneNumber(408, 867, 5309);
PhoneNumber pn2 = new PhoneNumber(408, 867, 5309); System.out.println(pn1.equals(pn2));//输出结果：true map.put(pn1, "Jany"); System.out.println(map.get(pn1));
System.out.println(map.get(pn2));
}
}
我们将覆盖了equals方法的类结合基于散列码的集合使用。从上面例子39行知道pn1实例和pn2实例是相等，行43代码输出的结果可想而知是Jany，但是行44输出什么呢，估计没有仔细考虑的话，可能第一感觉也会输出null。我们看下HashMap中get方法源码就知道了。
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key); return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
} int hash = (key == null) ? 0 : hash(key);//获取对象的hash值
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
//hash必须相等才有可能进行返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
从源码中得知get()方法是要根据hash值获取的。然后我们在看看pn1和pn2对象的hash码。
System.out.println(pn1.hashCode());//
System.out.println(pn2.hashCode());//2031122075
所以显而易见见，上述map.get(pn2) 的返回值是为null的。
修正这个问题很简单，在PhoneNumber类中覆盖hashCode()方法即可，先提供简单的案例：
@Override
public int hashCode() {
return 1;
}
这样的能满足上面那个例子map.get(pn2) 返回“Jany”，但是这样 所有实例都是返回一样的hashCode是不可取的。参考书中最正确的方式：
@Override
public int hashCode() {
int result = 17;
result = 31 * result + areaCode;
result = 31 * result + prefix;
result = 31 * result + lineNumer;
return 1;
}
