EffectiveJava笔记（二）-对于所有对象都通用的方法

对于所有对象都通用的方法

8.覆盖equals时请遵守通用约定

equals方法实现了等价关系

• 自反性 非null情况下 x.equals(s) return true
• 对称性 非null情况下 如果 y.equals(x) return true 则 x.equals(y) return true
• 传递性 非null情况下 x,y,z 如果 x.equals(y) return true && y.euqals(z) return true 则 x.equals(z) return true
• 一致性 非null情况下 x,y不被修改 x.equals(y) 结果不会变
• 对于任何非null的引用值 x， x.equals(null) 一定 return false

一个对称性冲突的例子 不建议如此书写代码

public final class CaseInsensitiveString {

    private final String s;

    public CaseInsensitiveString(String s) {
        if (s == null) {
            throw new NullPointerException();
        }
        this.s = s;
    }

    @Override
    public boolean equals(Object o) {
        if (o instanceof CaseInsensitiveString) {
            return s.equalsIgnoreCase(((CaseInsensitiveString) o).s);
        }
        // 为了解决对称性的问题 建议将下面于String 进行操作的代码删除
        if (o instanceof String) {
            return s.equalsIgnoreCase((String) o);
        }
        return false;
    }

    public static void main(String[] args) {
        CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
        String s = "polish";

        // 注意 这里违反了 equals的对称性
        // 对称性 非null情况下 如果  y.equals(x) return true 则  x.equals(y) return true
        // cis 的 equals 知道要忽略大小写 但 s.equals 不知道
        boolean result1 = cis.equals(s);
        System.out.println(result1);
        boolean result2 = s.equals(cis);
        System.out.println(result2);
    }

}

我们无法在拓展可实例化的类的同时，即增加新的值组件，同时有保留 equals约定吗

告诫

• 覆盖equals时总要覆盖hashCode
• 不要企图让equals方法过于智能
• 不要将equals声明中的Object对象替换为其他的类型

9.覆盖equals时总要覆盖hashCode

在每个覆盖了equals方法的类中，必须覆盖hashCode。如果不这样做就会违反Object，hashCode的通用约定，从而导致该类无法结合所有基于散列的集合一起正常工作，这些集合包括HashMap、HashSet和Hashtable。

• 在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对这同一个对象调用多次，hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。
• 如果两个对象根据equals(Object)方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
• 如果两个对象根据equals(Object)方法比较是不相等的。那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生不同的整数结果。但是程序员应该知道，给不相等的对象产生截然不同的整数结果，有可能提高散列表(hash table)的性能。

public class PhoneNumber {

    private final short areaCode;
    private final short prefix;
    private final short lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        rangeCheck(areaCode, 999, "area code");
        rangeCheck(prefix, 999, "prefix");
        rangeCheck(lineNumber, 9999, "line number");
        this.areaCode = (short) areaCode;
        this.prefix = (short) prefix;
        this.lineNumber = (short) lineNumber;
    }

    private static void rangeCheck(int arg, int max, String name) {
        if (arg < 0 || arg > max) {
            throw new IllegalArgumentException(name + ":" + arg);
        }
    }

    @Override
    public boolean equals(Object o) {

        if (o == this) {
            return true;
        }
        if (!(o instanceof PhoneNumber)) {
            return false;
        }
        PhoneNumber pn = (PhoneNumber) o;

        return pn.lineNumber == lineNumber
                && pn.prefix == prefix
                && pn.areaCode == areaCode;

    }

    @Override
    public int hashCode() {
        int result = 17;

        // 31 * i == (i << 5) - i;
        result = 31 * result + areaCode;
        result = 31 * result + prefix;
        result = 31 * result + lineNumber;
        return result;
    }

    public static void main(String[] args) {
        Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();
        m.put(new PhoneNumber(707, 867, 5309), "jenny");

        // 添加 hashCode后 可以获取到该 value
        // 如果不添加 hashCode 方法 这里获取到的 value是null
        String result = m.get(new PhoneNumber(707, 867, 5309));
        System.out.println(result);

    }

}

注：关于hashCode 的写法有一整套的数学公式 1.6前还没有支持函数化（散列函数） 需要自己写
有空查看一下 1.5之后有没有支持

10.始终要覆盖 toString

 PhoneNumber a = new PhoneNumber(707, 867, 5309);
        System.out.println(a.toString());

console

com.alan.effectivejava.chapter9.PhoneNumber@12960c

可以发现非常难以理解
建议尽量重写 toString方法

11.谨慎地覆盖clone

Cloneable（mixin interface）

Java中要想自定义类的对象可以被复制，自定义类就必须实现Cloneable中的clone()方法

注意 如何需要使用 clone方法 需要实现 Cloneable 接口

public class PhoneNumber implements Cloneable{

clone() 在java.lang.Object中的约定内容：

• x.clone() != x
  return true
• x.clone().getClass == x.getClass()
  return true
• x.clone().equals(x)
  return ture

@Override
public PhoneNumber clone() {
    try {
        return (PhoneNumber) super.clone();
    } catch (CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

public static void main(String[] args) {
    PhoneNumber a = new PhoneNumber(707, 867, 5309);
    System.out.println("克隆前：" + a.toString());
    PhoneNumber b = a.clone();
    System.out.println("克隆后：" + b.toString());
    System.out.println("判断值是否相等：" + a.equals(b));
}

console

克隆前：PhoneNumber{areaCode=707, prefix=867, lineNumber=5309}
克隆后：PhoneNumber{areaCode=707, prefix=867, lineNumber=5309}
判断值是否相等：true

上面可以看到
Java 1.5以后支持 协议返回类型（covariant return type） 即
目前覆盖方法的返回类型可以是被覆盖方法的返回类型的子类。

通则：永远不要让客户去做任何类库能够替客户完成的事情

如果对象中包含的域引用了可变的对象，像上面这样写会有问题，比如我们item6的stack为例子

  @Override
    public Stack clone() {
        try {
            Stack result = (Stack) super.clone();
//            result.elements = elements.clone();
            return result;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push("11");
        System.out.println("克隆前：" + stack);
        Stack cloneStack = stack.clone();
        System.out.println("克隆后：" + cloneStack);
        stack.pop();
        System.out.println("原始值：" + stack);
        System.out.println("克隆值：" + cloneStack);
    }

console

克隆前：Stack{elements=[11, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null], size=1}
克隆后：Stack{elements=[11, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null], size=1}
原始值：Stack{elements=[null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null], size=0}
克隆值：Stack{elements=[null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null], size=1}

可以看到 我们修改了 原始的stack对象 但我们复制的cloneStack对象的值也修改了。
这里我们就需要将这个stack栈的内部信息也拷贝。递归拷贝

@Override
public Stack clone() {
    try {
        Stack result = (Stack) super.clone();
        result.elements = elements.clone();
        return result;
    } catch (CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

console

克隆前：Stack{elements=[11, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null], size=1}
克隆后：Stack{elements=[11, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null], size=1}
原始值：Stack{elements=[null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null], size=0}
克隆值：Stack{elements=[11, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null], size=1}

现在看到的就是正确的值。我们将原始对象出栈一个值，这里没有修改到克隆对象的值。
因为克隆对象的elements已经是一个新的数组了。
所以 要注意对象中域是否引用了可变的对象。

迭代clone

clone构造器 & clone工厂

考虑实现Comparable接口