【JAVA学习】EffectiveJava的学习笔记--第二章 Object类的通用方法

Object类就是为了扩展用，其中非final方法（equals hashCode,toString,Clone,finalize）耳熟能详的方法在改写的时候必须要有很多通用约定，否则其他依赖于这些约定的类就无法与这些类正常工作。

1.equals方法

 1.1什么时候该改写equals方法？

       当一个类有自己的逻辑相等（而非对象身份）的概念，超类也没有改写equals以实现自己需要的行为时候，一般都是都是比较两个指向值对象的引用的时候，希望知道逻辑是否相等，而非指向同一个对象。

1.2 实现改写的通用约定

•    自反性：   x.equals(x) 为true
•    对称性：   x.equals(y) 为true,则   y.equals(x)也为true

下面这段代码coment部分的如果存在的话就违反了对称性，即equals方法中CaseInsensitiveString认识String类因此进行了判断，而反过来String类却人不认识CaseInsensitiveString类。这种不自觉的错误经常不经意就发生。

public class CaseInsensitiveString {
	
	private String s;
	public CaseInsensitiveString(String s) {
		if(s == null) {
			throw new NullPointerException();			
		}
		this.s = s;
	}
	
	public boolean equals(Object o) {
		if(o instanceof CaseInsensitiveString) {
			return  s.equalsIgnoreCase(((CaseInsensitiveString)o).s);
		}
		// 这段代码违反了对称性
//		if(o instanceof  String) {
//			return s.equalsIgnoreCase((String)o);
//		}
		return false;
	}
	
	public static void main(String[] args) {
		String s = "abc";
		CaseInsensitiveString cis = new CaseInsensitiveString("Abc");
		CaseInsensitiveString cis2 = new CaseInsensitiveString("ABC");
		System.out.println("cis.equals(s)= " +cis.equals(s));
		System.out.println("s.equals(cis) = " + s.equals(cis));
		System.out.println("cis2.equals(cis) = " + cis2.equals(cis));
	}
	
}

comment之前的结果是：

cis.equals(s)= true
s.equals(cis) = false
cis2.equals(cis) = true

comment段后的结果是：

cis.equals(s)= false
s.equals(cis) = false
cis2.equals(cis) = true

•    传递性：    x.equals(y) 为true    y.equals(z)为true, 则  x.equals(z)也为true
  

         这个问题经常发生在继承扩展一个值的类的时候，如果继承扩展的类没有override equals则，调用equals的时候就会出现以下问题。

import java.awt.Color;
import java.awt.Point;

public class ColorPoint  extends Point{
	private static final long serialVersionUID = 1L;
	private Color  color;
	public ColorPoint(int x, int y, Color color) {
		super(x,y);
		this.color = color;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Point p = new Point(1,2);
		ColorPoint cp1 = new ColorPoint(1, 2, Color.red);
		ColorPoint cp2 = new ColorPoint(1, 2, Color.black);		
		System.out.println("p.equals(cp1) =" + p.equals(cp1));
		System.out.println("p.equals(cp2) =" + p.equals(cp2));
		System.out.println("cp1.equals(cp2) =" + cp1.equals(cp2));
	}

}

得到的结果是

p.equals(cp1) =true
p.equals(cp2) =true
cp1.equals(cp2) =true 

但实际上cp1 和cp2是两个颜色不同的点。override equals方法后，虽然可以保证证对称性，但没有保证传递性，即p == p1  p==p2  得到的结果是p1 != p2.

	@Override
	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		if(!(obj instanceof Point)) {
			return false;
		}
		
		// if obj is normal point  do a color-blind comparasion
		if(!(obj instanceof ColorPoint)) {
			return this.equals(obj);
		}
		
		ColorPoint cp = (ColorPoint)obj;
		return super.equals(obj) && (cp.color == this.color);
	}

得到的结果是：

p.equals(cp1) =true
p.equals(cp2) =true
cp1.equals(cp2) =false

为了解决这个传递性的问题，一般要扩展可实例化的类的同时，既要增加新的特征，又要保留equals的约定，没有办法做到。

另外一种解决方案是 采用【复合】的方式。

即ColorPoint不是继承与Point,而是该类包含了一个Point的成员变量。

•   非空性：   非空引用值 x  x.equals(null) 则返回false，非空不用多说了，就是上面override里面的加上null 的判断。
• 对于类中每个关键域，检查实参中与当前对象中对应的域是否匹配。 
  

1.3检查equals方法的一些小结：

•           如果该类的类型是接口，则通过接口访问实参中的关键域
•           如果该类的类型是类，则访问实参中的关键域。
•           对于不是float 也不是double则可以直接用==比较，对于对象引用域则可以用递归的equals方法，
•           对于float则使用Float.floatToIntBits转换成int类型的值，再==比较
•           对于double则使用Double.doubleToLongBits转换成long型的值，再==比较
•           对于数组域，则以应用到元素上，有些对象引用域包含null是合法的，所以为了避免null异常，可以通过判断该field是不是null然后再进行常规的equals比较。
  

 1.4 修改equals的时候一定要修改hashcode方法，否则违反了相等的对象必须有相等的散列码。

     这个下一篇再记述。