[Effective Java] (11) 谨慎地覆盖clone

Cloneable接口的目的是作为对象的mixin接口(mixin interface)，表明这样的对象允许克隆(clone)。
不能仅仅因为一个对象实现了Cloneable，就可以调用clone方法。
实现接口是为了表明类可以为客户做些什么，然而对于Cloneable接口，它改变了超类中受保护的方法行为。

1. Cloneable接口的作用

该接口决定了Object中受保护的clone方法的实现行为：

• 如果一个类实现了Cloneable接口，Object的clone方法返回该对象的逐域拷贝；
• 如果一个类未实现Cloneable接口，则该对象就会抛出CloneNotSupportedException异常。

2. clone方法的约定

• clone方法的约定通常是非常弱的，以下要求在clone方法中都不是绝对要求：

x.clone() != x;                             //将会是true
x.clone().getClass() == x.getClass();       //将会是true
x.clone().equals(x);                        //将会是true

• 拷贝对象往往会导致创建它的类的一个新实例，但它同时也会要求拷贝内部的数据结构，在这个过程中不许调用构造器。

3. 实现clone方法

• 超类能够提供克隆功能的唯一途径是返回一个通过调用super.clone而得到的对象；
• 如果覆盖了非final类中的clone方法，则应该返回一个通过调用super.clone而得到的对象，如果类所有的超类都遵守这条规则那么调用super.clone最终会调用Object的clone方法，从而创造出正确类的实例。（机制为自动调用链，非强制要求）
• 如果待克隆的域仅仅包含一个基本类型的值，或者包含一个指向不可变对象的引用，则被返回的对象可能是正需要的对象，如果不是，需要另作处理

4. 非基本类型clone

• Stack中的数组

public class Stack {
    private Object[] elements;
}

// clone时需要拷贝栈的内部信息，

// elements数组递归调用clone方法
@Override
public Stack clone() {
    try {
        Stack result = (Stack) super.clone();
        result.elements = elements.clone();
        return result;
    } catch (CloneNotSupportedException e) {
        throw new AssertionError();
    }
}

// 我们不一定将elements.clone()的结果转换成Object[]。
// 自Java1.5发行版起，在数组上调用clone返回数组的数组，其编译时类型与被克隆数组的类型相同
// 注：如果elements域是final的，上述方案就不能正常工作，因为clone方法是被禁止给elements域赋新值
// (clone架构与引用可变对象的final域的正常使用时不兼容的)

• 散列桶中的数组
  正在为一个散列表编写clone方法，它的内部数据包含一个散列桶数组，每个散列桶都指向“键-值”对链表的第一个项，如果桶是空的，则为null。该类如下：

public class HashTable implements Cloneable {
    private Entry[] buckets = ...;
    private static class Entry {
        final Object key;
        Object value;
        Entry next;
        Entry (Object key, Object value, Entry next) {
            this.key = key;
            this.value = value;
        }
    }
}

// clone时不仅需要递归的克隆这个散列桶数组，
// 而且需要单独的拷贝并组成每个桶的列表，下面是常用做法

@Override
public HashTable clone() {
    try {
        HashTable result = (HashTable) super.clone();
        result.buckets = new Entry[buckets.length];
        for (int i = 0; i < buckets.length; i++) {
            if (buckets[i] != null) {
                result.buckets[i] = buckets[i].deepCopy();
            }
        }
    } catch (CloneNotSupportException e) {
        throw new AssertionError();
    }
}

// 私有类的HashTable.Entry被加强了，支持一个“深拷贝(deep copy)”方法
// 防止因链表过长导致栈溢出，可采用迭代(Iteration)的方法代替递归(recursion)

// 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;
}

• 复杂对象的克隆
  先调用super.clone，然后把结果对象中的所有域设置成他们的空白状态(virgin state)，然后调用高层的方法来重新产生对象的状态。这种做法往往会产生一个简单、合理且相当优美的clone方法，但通常没有直接操作对象及其克隆对象的内部状态的clone方法快。

• 总而言之，实现了Cloneable接口的类都应该用一个共有的方法覆盖clone。此公有方法首先调用super.clone，然后修正任何需要修改的域。

5. 代替方法

• 另外实现对象拷贝的好办法是提供一个拷贝构造器(copy constructor)或拷贝工厂(copy factory)。拷贝构造器只是一个构造器，它唯一的参数类型是包含该构造器的类。如：

public Yum(Yum yum);

// 拷贝工厂类似于拷贝构造器的静态工厂：
public static Yum newInstance(Yum yum);

• 拷贝构造器的优点

1. 其不依赖于某一种很有风险的、语言之外的对象创建机制；
2. 其不遵守尚未制定好的文档规范；
3. 其不会与final域的正常使用发生冲突；
4. 其不会抛出不必要的受检查异常；
5. 其不需要类型转换；
6. 采用其代替clone方法时，并没有放弃接口功能特性。

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