/** * 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 <tt>x</tt>, the expression: * * <blockquote> * * <pre> * x.clone() != x</pre> * * </blockquote> * * will be true, and that the expression: * * <blockquote> * * <pre> * x.clone().getClass() == x.getClass()</pre> * * </blockquote> * * will be <tt>true</tt>, but these are not absolute requirements. While it is typically the case * that: * * <blockquote> * * <pre> * x.clone().equals(x)</pre> * * </blockquote> * * will be <tt>true</tt>, this is not an absolute requirement. * * <p>By convention, the returned object should be obtained by calling <tt>super.clone</tt>. If a * class and all of its superclasses (except <tt>Object</tt>) obey this convention, it will be the * case that <tt>x.clone().getClass() == x.getClass()</tt>. * * <p>By convention, the object returned by this method should be independent of this object * (which is being cloned). To achieve this independence, it may be necessary to modify one or * more fields of the object returned by <tt>super.clone</tt> before returning it. Typically, this * means copying any mutable objects that comprise the internal "deep structure" of the object * being cloned and replacing the references to these objects with references to the copies. If a * class contains only primitive fields or references to immutable objects, then it is usually the * case that no fields in the object returned by <tt>super.clone</tt> need to be modified. * * <p>The method <tt>clone</tt> for class <tt>Object</tt> performs a specific cloning operation. * First, if the class of this object does not implement the interface <tt>Cloneable</tt>, then a * <tt>CloneNotSupportedException</tt> is thrown. Note that all arrays are considered to implement * the interface <tt>Cloneable</tt>. Otherwise, this method creates a new instance of the class of * this object and initializes all its fields with exactly the contents of the corresponding * fields of this object, as if by assignment; the contents of the fields are not themselves * cloned. Thus, this method performs a "shallow copy" of this object, not a "deep copy" * operation. * * <p>The class <tt>Object</tt> does not itself implement the interface <tt>Cloneable</tt>, so * calling the <tt>clone</tt> method on an object whose class is <tt>Object</tt> will result in * throwing an exception at run time. * * @return a clone of this instance. * @exception CloneNotSupportedException if the object's class does not support the <code> * Cloneable</code> interface. Subclasses that override the <code>clone</code> method can also * throw this exception to indicate that an instance cannot be cloned. * @see java.lang.Cloneable */ protected Object clone() throws CloneNotSupportedException { return VM.shallowCopy(this); }