/** * This method may be called to create a new copy of the * Object. The typical behavior is as follows:<br> * <ul> * <li><code>o == o.clone()</code> is false</li> * <li><code>o.getClass() == o.clone().getClass()</code> * is true</li> * <li><code>o.equals(o)</code> is true</li> * </ul> * * <p>However, these are not strict requirements, and may * be violated if necessary. Of the three requirements, the * last is the most commonly violated, particularly if the * subclass does not override {@link #equals(Object)}. * * <p>If the Object you call clone() on does not implement * {@link Cloneable} (which is a placeholder interface), then * a CloneNotSupportedException is thrown. Notice that * Object does not implement Cloneable; this method exists * as a convenience for subclasses that do. * * <p>Object's implementation of clone allocates space for the * new Object using the correct class, without calling any * constructors, and then fills in all of the new field values * with the old field values. Thus, it is a shallow copy. * However, subclasses are permitted to make a deep copy. * * <p>All array types implement Cloneable, and override * this method as follows (it should never fail):<br> * <pre> * public Object clone() * { * try * { * super.clone(); * } * catch (CloneNotSupportedException e) * { * throw new InternalError(e.getMessage()); * } * } * </pre> * * @return a copy of the Object * @throws CloneNotSupportedException If this Object does not * implement Cloneable * @throws OutOfMemoryError Since cloning involves memory allocation, * even though it may bypass constructors, you might run * out of memory * @see Cloneable */ //protected Object clone() throws CloneNotSupportedException //{ // if (this instanceof Cloneable) // return VMObject.clone((Cloneable) this); // throw new CloneNotSupportedException("Object not cloneable"); //}/*Tehat a klonozando osztalynak kotelezo jelleggel implementalnia kell a Cloneable interfeszt, kulonben hibat dob es nem kapunk klont.Ha ez megvan, akkor a super.clone() visszaadja az adott objektum klonjat Object-kent, ezt kasztolva megkapjuk a kivant tipusu klont :)Ebben az esetben a CloneNotSupportedException lekezelese igaz kotelezo, de sosem fog elofordulni :P*/class Cloning{ public static void main(String[] args) { Object obj1 = new Object(); // itt azert hasal el forditaskor, mert a clone() metodus protected, // es jelenleg nem erjuk el //1.// Object obj2 = obj1.clone(); Cloning c1 = new Cloning(); // itt mar mukodik, hisz elerjuk // de a default clone() metodus implementacioja miatt Object visszateresi erteke van //2.// Cloning c2 = c1.clone(); // castolni kell, kivetelkezelni es voila :) try { Cloning c3 = (Cloning)c1.clone(); } catch (CloneNotSupportedException cnse) { // de ez meg mindig hibat dob, mivel nincs implementalva a Cloning interface :) cnse.printStackTrace(); } // HELYES Cloning2 c21 = new Cloning2(); Cloning2 c22 = c21.clone(); }}class Cloning2 implements Cloneable{ @Override protected/* or public*/ Cloning2 clone() { try { Object clone1 = super.clone(); Cloning2 clone2 = (Cloning2)clone1; return clone2; } catch (CloneNotSupportedException cnse) { System.out.println("Never happens!"); return null; } }}