Principles
- If you override the clone method in a nonfinal class, you should return an object obtained by invoking super.clone
-
In practice, a class that implements Cloneable is expected to provide a properly
functioning public clone method.
- Never make the client do anything the library can do for the client.
- The clone architecture is incompatible with normal use of final fields referring to mutable objects
Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object.
The general intent is that, for any object x, the expression
x.clone() != x will be true,
x.clone().getClass() == x.getClass() will be true,
but these are not absolute requirements. While it is typically the case that
x.clone().equals(x) will be true,
this is not an absolute requirement. Copying an object will typically entail creating a new instance of its class, but it may require copying of internal data structures as well. No constructors are called.
The return type of the method is subclass instead of the super class which means this is applied with covariant which is introduced from JRE 1.5. As the code shown below:
@Override public PhoneNumber clone() {
try {
return (PhoneNumber) super.clone();
} catch(CloneNotSupportedException e) {
throw new AssertionError(); // Can't happen
}
}
import java.util.Arrays;
import java.util.EmptyStackException;
public class Stack implements Cloneable {
private Object[] elements;
private int size = 0;
private static final int DEFAULT_INITIAL_CAPACITY = 16;
public Stack() {
this.elements = new Object[DEFAULT_INITIAL_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; // Eliminate obsolete reference
return result;
}
// Ensure space for at least one more element.
private void ensureCapacity() {
if (elements.length == size)
elements = Arrays.copyOf(elements, 2 * size + 1);
}
@Override
protected Object clone() throws CloneNotSupportedException {
try {
Stack result = (Stack) super.clone();
// Do recursive clone with a class.
result.elements = elements.clone();
return result;
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
}
Implement clone with recursive clone method.
public class Hashtable implements Cloneable {
private Entry[] buckets = new Entry[3];
private static class Entry {
final Object key;
Object value;
Entry next;
Entry(Object key, Object value, Entry next) {
this.key = key;
this.value = value;
this.next = next;
}
// Recursively copy the linked list headed by this Entry
Entry deepCopy() {
return new Entry(key, value, next == null ? null : next.deepCopy());
}
@Override
public String toString() {
return String.format("[key: %d, value: %s, next: %s]", key, value,
next);
}
}
public static void main(String[] args) {
Hashtable ht = new Hashtable();
Entry previous = null;
for (int i = 0; i < 3; i++) {
Entry e = new Entry(i, "v" + i, previous);
ht.buckets[i] = e;
}
Hashtable newHt = ht.clone();
newHt.buckets[newHt.buckets.length - 1] = new Entry(
newHt.buckets[newHt.buckets.length - 1].key,
newHt.buckets[newHt.buckets.length - 1].value
+ String.valueOf(1),
newHt.buckets[newHt.buckets.length - 1].next);
System.out.println("newHt");
for (int i = 0; i < newHt.buckets.length; i++) {
System.out.println(newHt.buckets[i]);
}
System.out.println("ht");
for (int i = 0; i < ht.buckets.length; i++) {
System.out.println(ht.buckets[i]);
}
}
@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();
return result;
} catch (CloneNotSupportedException e) {
throw new AssertionError();
}
}
}
To prevent a stack overflow caused by the lengthy stack frame for each element in the list from happening. We can implement the code like this below:
// 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;
}
Summary
- Like a constructor, a clonemethod should not invoke any nonfinal methods on the clone under construction (Item 17).
- Object's clone method is declared to throw CloneNotSupportedException, but overriding clone methods can omit this declaration. But if the subclass overrides its superclass's clone method it should be declared as proteteced and throw CloneNotSupportedException and the class should not implment Cloneable.
- To make a thread-safe class implement Cloneable you must ensure its clone method be synchronized just like other methods.
-
Class which implement Cloneable should override clone with public method return itself.
- First call super.clone.
-
Fix any fields that is not primitive or immutable type object.
- Call the field's clone method recursively.
- Handle the exception case that if the object represent a unique ID or serial number or creating time even if they are primitive type or a reference to immutable object.
-
If it's not appropriate way to provide an alternative means of object coping or simply not providing the capability of cloneable(such as immutable class) then just provide a copy constructor or copy factory.
- Public Yum(Yum yum);
-
Public static Yum newInstance(Yum yum);