Clone提供一種語言之外的機制：無需呼叫構造器就可以建立物件。

它的通用約定非常弱：

建立和返回該物件的一個拷貝。這個拷貝的精確含義取決於該物件的類。一般含義是，對於任何物件x，表示式x.clone() != x 將會是true，並且，表示式x.clone().getClass() == x.getClass() 將會是true，但這些不是絕對的要求，通常情況下，表示式 x.clone().equals(x) 將會是true，這也不是一個絕對的要求，拷貝物件往往是建立它的類的一個新例項，但它同時也會要求拷貝內部的資料結構。

如果類的每個域包含一個基本型別的值，或者包含一個指向不可變物件的引用，那麼被返回的物件則正是所需要的物件，如PhoneNumber類：

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();
        }
    }
}

只需要簡單地呼叫super.clone() 而不用做進一步的處理。

如果物件中包含的域引用了可變的物件：

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

如果把這個類做成是可克隆的。如果它的clone方法僅僅返回super.clone()，這樣得到的Stack例項，在size域有正確的值，但它的elements域將引用與原始Stack例項相同的陣列。

為了使Stack類中的clone方法正常地工作，必須拷貝棧的內部資訊：

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

如果elements域是final的，上面的clone方法無法正常工作，因為clone方法被禁止給elements賦新值。

另一個實現物件拷貝的好辦法是提供一個拷貝構造器或拷貝工廠。拷貝構造器只是一個構造器，它唯一的引數型別是包含該構造器的類，例如 public Yum(Yum yun);

拷貝工廠是類似於拷貝構造器的靜態工廠：public static Yum newInstance(Yum yum);

它們不依賴於有風險的、語言之外的物件建立機制，也不要求遵守尚未制定好文件的規範，不會與fianl域的正常使用發生衝突，不丟擲不必要的受檢異常，不需要進行型別轉換。

拷貝構造器或者拷貝工廠可以帶一個引數，引數型別是通過該類實現的介面，例如所有通用集合實現都提供一個拷貝構造器，它的引數型別是Collection或者Map。基於介面的拷貝構造器和拷貝工廠允許客戶選擇拷貝的實現型別，例如假設有一個HashSet s，希望把它拷貝成一個TreeSet，clone方法無法提供這樣的功能，但用轉換構造器實現：new TreeSet(s)。

cloneable的問題導致我們不應該擴充套件這個介面，為了繼承而設計的類也不應該實現這個介面，由於它具有這麼多缺點，專家級的程式設計師從來不去覆蓋clone方法， 也從來不去呼叫它，除非拷貝陣列。

對於一個專門為繼承而設計的類，如果未能提供行為良好的受保護clone方法，它的子類就不可能實現Cloneable介面。