clonazione di oggetti con l'implementazione dell'interfaccia clonabile

Question

per clonare l'oggetto è necessario implementare l'interfaccia 'clonabile'. perché qui la mia classe è un file jar (intendo API). quindi non posso modificare la classe. Ho sentito che tutte le classi estendono la classe dell'oggetto base e questa classe oggetto implementa l'interfaccia clonabile. questo significa che possiamo clonare direttamente l'oggetto senza implementare l'interfaccia. se è così nella mia eclissi non ho alcuna possibilità di clonare l'oggetto. c'è un altro modo per clonare l'oggetto senza implementare l'interfaccia clonabile. Spiega per favore.

Answer 1

la classe Java Object non implementa l'interfaccia Cloneable. Ha tuttavia il metodo clone(). Ma questo metodo è protected e getterà CloneNotSupportedException se chiamato su un oggetto che non implementa l'interfaccia Cloneable. Quindi se non riesci a modificare la classe che vuoi clonare sei sfortunato e dovrai trovare un altro modo per copiare l'istanza.

Va notato tuttavia che il sistema clone in Java è pieno di buchi e generalmente non più utilizzato. Dai un'occhiata a questo interview con Josh Bloch del 2002 che spiega alcuni dei problemi.

Answer 2

Tentativo di richiamare il metodo clone su una classe che non implementa Cloneable genera Eccezione CloneNotSupported e nessuna classe Object non implementa Cloneable.

Ecco l'javadoc dal metodo clone di classe Object

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. 

anche oggetto metodo # clone è protetto quindi è necessario implementare il metodo clone nella classe e renderlo pubblico in modo che possa essere accessibile a classi che creano oggetti della tua classe che possono quindi richiamare il clone. Un buon esempio è il modo in cui è clone di implementare in ArrayList

ArrayList implementa clonabile come qui di seguito public class ArrayList estende AbstractList implementa List, RandomAccess, Cloneable, java.io.Serializable

e poi implementa il metodo clone:

/** 
* Returns a shallow copy of this <tt>ArrayList</tt> instance. (The 
* elements themselves are not copied.) 
* 
* @return a clone of this <tt>ArrayList</tt> instance 
*/ 
public Object clone() { 
try { 
    ArrayList<E> v = (ArrayList<E>) super.clone(); 
    v.elementData = Arrays.copyOf(elementData, size); 
    v.modCount = 0; 
    return v; 
} catch (CloneNotSupportedException e) { 
    // this shouldn't happen, since we are Cloneable 
    throw new InternalError(); 
} 
} 

Answer 3

Il metodo clone() nella classe Object è protetto, il che significa che tutte le classi lo erediteranno con il modificatore di accesso protetto, quindi se provate ad accedervi al di fuori di quella classe senza clonarlo non lo vedrete, inoltre vi verrà lanciato CloneNotSupportedException se si tenta di richiamarlo senza implementare l'interfaccia Cloneable.

Nel caso in cui si stia cercando di creare un comportamento di clonazione, è necessario scrivere un nuovo metodo nella classe e quindi creare una copia di tutti i campi in esso, è fondamentalmente come creare una nuova copia di un stato esistente di un oggetto.

public class TestCloneable { 
private String name = null; 

/** 
* @param name the name to set 
*/ 
public void setName(String name) { 
    this.name = name; 
} 

/** 
* @return the name 
*/ 
public String getName() { 
    return name; 
} 


public TestCloneable createCopy(){ 
    TestCloneable testCloneable = new TestCloneable(); 
    testCloneable.setName(this.getName()); 
    return testCloneable; 
} 

}

Answer 4

di solito le migliori pratiche per evitare clone() in ogni caso, perché è difficile da fare correttamente (http://www.javapractices.com/topic/TopicAction.do?Id=71). Forse la classe in questione ha un costruttore di copie?

In alternativa, se si implementa Serializable o Externalizable, è possibile copiarlo profonda scrivendo ad un flusso di byte e la lettura di nuovo nel

ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
ObjectOutputStream oos = new ObjectOutputStream(baos); 
oos.writeObject(this); 
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); 
ObjectInputStream ois = new ObjectInputStream(bais); 
Object deepCopy = ois.readObject(); 

(da http://www.jguru.com/faq/view.jsp?EID=20435).Questo è semplice e veloce, ma non bello ... In genere lo considererei l'ultima risorsa.

Answer 5

Loro è un api che clona l'oggetto senza implementare l'interfaccia clonabile.

Prova questa

https://code.google.com/p/cloning/

Inoltre è possibile trovare maggiori dettagli sugli oggetti clonazione qui

http://javatechniques.com/blog/faster-deep-copies-of-java-objects/

Answer 6

Non è obbligatorio per implementare l'interfaccia clonabile di fare un clone di un oggetto. È possibile scrivere il proprio metodo di clonazione nella classe di cui si desidera clonare l'oggetto.