Effective Java之谨慎地覆盖clone(十一)

Clone提供一种语言之外的机制：无需调用构造器就可以创建对象。

它的通用约定非常弱：

创建和返回该对象的一个拷贝。这个拷贝的精确含义取决于该对象的类。一般含义是，对于任何对象x，表达式x.clone() != x 将会是true，并且，表达式x.clone().getClass() == x.getClass() 将会是true，但这些不是绝对的要求，通常情况下，表达式 x.clone().equals(x) 将会是true，这也不是一个绝对的要求，拷贝对象往往是创建它的类的一个新实例，但它同时也会要求拷贝内部的数据结构。

如果类的每个域包含一个基本类型的值，或者包含一个指向不可变对象的引用，那么被返回的对象则正是所需要的对象，如

public class PhoneNumber implements Cloneable{
    private final int areaCode;
    private final int prefix;
    private final int 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 = areaCode;
        this.prefix = prefix;
        this.lineNumber = 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 PhoneNumber clone() {
        try {
            return (PhoneNumber) super.clone();
        } catch(CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

不可变类包括String，Integer，Short等包装类。

而如果对象中包含的域引用了可变的对象，如：

public class Stack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITAL_CAPACITY = 16;

    public Stack() {
        elements = new Object[DEFAULT_INITAL_CAPACITY];
    }

    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public Object pop() {
        if(size == 0) {
            throw new EmptyStackException();
        }
        Object result = elements[--size];
        elements[size] = null;
        return result;
    }

    private void ensureCapacity() {
        if(elements.length == size)
            elements = Arrays.copyOf(elements, 2 * size + 1);
    }
}

那么我们就要对引用对象进行深度赋值。
这里应该：

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

如果是Integer等不可变对象，则不用进行clone，如果是数组，包括普通类型数组，或者包装类型数组，如int[],Integer[]则都要进行clone。

cloneable的问题导致我们不应该扩展这个接口，为了继承而设计的类也不应该实现这个接口，由于它具有这么多缺点，专家级的程序员从来不去覆盖clone方法， 也从来不去调用它，除非拷贝数组。

对于一个专门为继承而设计的类，如果未能提供行为良好的受保护clone方法，它的子类就不可能实现Cloneable接口。

要想实现真正的深复制而不希望实现Cloneable接口，可行的办法是实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。不过因为序列化和反序列化，会造成一定的性能损失。