Java 中的Clone 学习总结

1. 一个类需要实现clone. 一个最佳实践是它需要实现 Cloneable 接口并且提供一个 public clone 方法。

Object 对象的clone 方法是protected。 不重写这个方法， 我们不能够调用一个对象的clone 方法， 除非利用反射。

2. 如果给一个 nonfinal 类重写clone方法。应该通过调用 super.clone获得对象。
因为有个约束， x.clone().getClass() 应该和x.getClass()一致。 所以， 也不要通过构造器去实现clone.

3。当调用clone方法后， 这个类定义的所有属性都回被copy， 并且clone后所有属性的值都会跟那个源对象一样。 如果这个类的所有属性是基本类型或者引用的是不可改变的类型（final） ， 就像 String, 那么， 这个clone后获得的对象， 就是我们确切需要的对象。它不需要进一步做任何操作 （当然， 如果某些值是要做唯一性处理的。 也要改）。

package util;

public final class PhoneNumber {
	private final short areaCode;
	private final short exchange;
	private final short extension;

	public PhoneNumber(int areaCode, int exchange, int extension) {
		rangeCheck(areaCode, 999, "area code");
		rangeCheck(exchange, 999, "exchange");
		rangeCheck(extension, 9999, "extension");
		this.areaCode = (short) areaCode;
		this.exchange = (short) exchange;
		this.extension = (short) extension;
	}

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

	public boolean equals(Object o) {
		if (o == this)
			return true;
		if (!(o instanceof PhoneNumber))
			return false;
		PhoneNumber pn = (PhoneNumber) o;
		return pn.extension == extension && pn.exchange == exchange
				&& pn.areaCode == areaCode;
	}

	[b]public Object clone() {
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			throw new Error("Assertion failure"); // Can't happen
		}
	}[/b]
}

但是， 当有fields引用可变的对象时候， 简单的使用上面的实现， 会发生错误。 例如

public class Stack {
	private Object[] elements;
	private int size = 0;

	public Stack(int initialCapacity) {
		this.elements = new Object[initialCapacity];
	}

	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; // Eliminate obsolete reference
		return result;
	}

	// Ensure space for at least one more element.
	private void ensureCapacity() {
		if (elements.length == size) {
			Object oldElements[] = elements;
			elements = new Object[2 * elements.length + 1];
			System.arraycopy(oldElements, 0, elements, 0, size);
		}
	}
}

如果需要把上面的这个类可以cloneable， 而clone方法， 仅仅返回super.clone(). 对于field size会有正确的值， 但field elements 会引用同一个对象。 改变原对象或克隆对象时候， 都会同时影响两个对象。 这时候， 参考下面的原则。

4. clone 方法是作为另外一个构造方法， 你必须保证克隆对象不会影响到源对象。 这时需要对clone方法做一些改变。即我们需要做深度克隆。 例如：

	public Object clone() throws CloneNotSupportedException {
		Stack result = (Stack) super.clone();
		result.elements = (Object[]) elements.clone();
		return result;
	}

这样的话， 其实要每一层， 每个可变对象都实现良好的克隆。 但是

如果一个类的有些field 是 final的话， 会有些麻烦。 因为克隆中， 试图给一个final field赋值是不可能的（java 基本特性）。 这时候， 可能考虑两种做法。 一是如果可变对象可以在克隆对象和源对象之间安全共享的话， 就不需要做深度克隆 （这里的final, 可变对象不会给大家造成混淆吧？）。另外一种做法是把final 去掉。

从JDK中取个deeply copy 的例子：
HashMap 实现的事shallow copy, HashTable实现的话，某些是deep copy. 例如里面的一个链表实现。
这里简单的介绍下HashTable的实现。
HashTable 里有个Entry 对象数组 Entry[] buckets。
根据上面的分析，我们知道要实现深度克隆， 需要递归调用buckets.clone方法。 如果buckets 数组里的对象仍然还是可变对象 （Entry）， 那么还要递归调用Entry.clone方法。 直到基本类型或final类型。 参考下面的源代码片断：

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {

    /**
     * The hash table data.
     */
    private transient Entry[] table;

    /**
     * The total number of entries in the hash table.
     */
    private transient int count;

    /**
     * The table is rehashed when its size exceeds this threshold.  (The
     * value of this field is (int)(capacity * loadFactor).)
     *
     * @serial
     */
    private int threshold;

    /**
     * The load factor for the hashtable.
     *
     * @serial
     */
    private float loadFactor;
 ......

// Entry 其实是一个链表的简单实现
  /**
     * Hashtable collision list.  
     */
    private static class Entry<K,V> implements Map.Entry<K,V> {
	int hash;
	K key;
	V value;
	Entry<K,V> next;

	protected Entry(int hash, K key, V value, Entry<K,V> next) {
	    this.hash = hash;
	    this.key = key;
	    this.value = value;
	    this.next = next;
	}

	protected Object clone() {
	    return new Entry<K,V>(hash, key, value,
				  (next==null ? null : (Entry<K,V>) next.clone()));
	}

 .....

 /**
     * Creates a shallow copy of this hashtable. All the structure of the
     * hashtable itself is copied, but the keys and values are not cloned.
     * This is a relatively expensive operation.
     *
     * @return  a clone of the hashtable
     */
    public synchronized Object clone() {
	try {
	    Hashtable<K,V> t = (Hashtable<K,V>) super.clone();
	    t.table = new Entry[table.length];
	    for (int i = table.length ; i-- > 0 ; ) {
		t.table[i] = (table[i] != null)
		    ? (Entry<K,V>) table[i].clone() : null;
	    }
	    t.keySet = null;
	    t.entrySet = null;
            t.values = null;
	    t.modCount = 0;
	    return t;
	} catch (CloneNotSupportedException e) {
	    // this shouldn't happen, since we are Cloneable
	    throw new InternalError();
	}
    }

其实， 上面的Entry 的copy方法在链表elements比较大时候， 会有点问题。 因为每个element都会copy一个链表出来。 这回可能发生stack overflow. 用下面的方法， 可以防止这种情况发生。

            // Iteratively copy the linked list headed by this Entry
           Entry deepCopy() {
           Entry result = new Entry(key, value, next);
          for (Entry p = result; p.next != null; p = p.next)
                    p.next = new Entry(p.next.key, p.next.value, p.next.next);
          return result;
}

5. Clone 方法， 不要调用非final 方法。 如果调用的方法被override. 子类调用clone时， 子类的值可能被改变。 所有一般调用final或者private方法。