[java] Non riesco a clonare gli oggetti presenti in una classe

[gomo]

Ciao a tutti, ho creato una classe Notebook che implementa l'interfaccia cloneable e che contiene un oggetto notes di tipo ArrayList. Al suo interno ho ridefinito il metodo clone al fine di ottenere una copia completa degli oggetti istanziati con Notebook.

 public Object clone()
    {
        Object oggettoClonato = null;
        try
        {
            oggettoClonato = super.clone();
            oggettoClonato.notes = notes.clone();
            
        }
        catch(CloneNotSupportedException e)
        {
            System.out.println("Errore: oggetto non Clonabile");
        }
        return clone;
    }

In compilazione mi da l'errore "cannnot find symbol - variable notes". Se oggettoClonato è una copia di notes non dovrebbe avere anch'esso un campo notes?

[andbin]

Originariamente inviato da gomo

        Object oggettoClonato = null;

In compilazione mi da l'errore "cannnot find symbol - variable notes"

Già ... perché la variabile l'hai dichiarata di tipo Object!!!! Quindi con 'oggettoClonato' che è di tipo Object non puoi certo referenziare un campo 'notes' che ovviamente in Object non esiste.

E nota alcune cose:
- nel return hai messo un 'clone' che non centra
- tieni presente che un ArrayList è sì clonabile ma ... la copia è "shallow" ovvero hai in effetti un nuovo oggetto ArrayList ma entrambi (quello originale e quello nuovo) fanno riferimento agli stessi oggetti contenuti! Se gli oggetti contenuti sono "immutabili" no problem. Se fossero mutabili ... problems!
- La eccezione CloneNotSupportedException non dovrebbe mai capitare, visto che il tuo oggetto implementa Cloneable e il clone() di ArrayList pure funziona. Quindi invece del println puoi tranquillamente mettere: throw new Error("errore grave");. Come a dire: se succedesse davvero ... beh, butta via tutto, è una cosa molto grave!!!

[matthew80]

Eccoti il codice per una classe "clonabile":

 class MyClass implements Cloneable {
        public MyClass() {
        }
        public Object clone() {
            Cloneable theClone = new MyClass();
            // Initialize theClone.
            return theClone;
        }
    } 

Di seguito il codice per creare un clone.

MyClass myObject = new MyClass();
    MyClass myObjectClone = (MyClass)myObject.clone(); 

Gli Arrays sono automaticamente cloneable:

    int[] ints = new int[]{123, 234};
    int[] intsClone = (int[])ints.clone(); 

Spero che questi esempi, anche se minimali, ti siano utili.

[andbin]

Originariamente inviato da matthew80

Cloneable theClone = new MyClass(); 

Generalmente è meglio invocare il clone() di Object, almeno fa già lui la copia dei campi.

Originariamente inviato da matthew80
Gli Arrays sono automaticamente cloneable:

Sì ma la copia è "shallow" (l'unico caso in cui si ha una "deep" copy è per array di primitivi a 1 dimensione). E da Java 5 il clone() degli array usa il return "covariante" ovvero si può evitare il cast.

[gomo]

Grazie, sono riuscito a clonare la classe. Solo che al suo interno faccio uso di un ArrayList e praticamente la nuova copia ora condivide i dati con la vecchia nel senso che se modifico la vecchia risulta modificata anche al nuova. Magari clonando uno ad uno gli elementi dell'ArrayList...

[matthew80]

ok andbin, ho letto questa soluzione in un articolo sulla clonazione.
Secondo te va bene? sai com'è non vorrei sbagliare anche io semmai dovessi averne bisogno

##################################################
Una soluzione efficente si ha implementando l'interfaccia Cloneable e ridefinendo il metodo clone della classe Object per ogni classe utilizzata.

    public class InnerObject implements Cloneable {

         public int attribute;

         // restituisce la copia dell'oggetto.
         public Object clone() {
            return super.clone()
         }
       
         // [...]
    } 

    public class Container implements Cloneable {

         public InnerObject myObject;

         public Object clone() {

             // cast di tipo perché clone restituisce un object
             Container temp = (Container)super.clone();

             // clono l'oggetto interno...
             temp.myObject = (InnerObject)myObject.clone();

             // restituisco la copia esatta..
             return temp;
         }
    } 

    // *** nel main() *** //

    Container obj = new Container();

    // chiamata al costruttore di copia in Java...
    Container copy = (Container)obj.clone();

    obj1.myObject.attribute = 10;
    copy.myObject.attribute = 0;

    System.out.println(obj1.myObject.attribute +
    "," + copy.myObject.attribute); // output: 10,0 

[andbin]

Originariamente inviato da matthew80
Secondo te va bene?

No, non va bene. Devi tenere presente che il clone() di Object dichiara di lanciare CloneNotSupportedException (che effettivamente lancia se trova che l'oggetto non è clonabile).
Quindi non puoi non tenerne conto!!! Devi catturare la eccezione e visto che tu "sai" che la tua classe è Cloneable, nel catch puoi anche non fare nulla (tanto non dovrebbe mai capitare) o al limite lanciare un Error ... insomma se capitasse = errore grave.

[matthew80]

Quando posto codice qui lo purgo di gestione dell'eccezione e quant'altro per non appesantire la lettura...dico - a parte la gestione delle eccezione che ovviamente implemento nel codice finale - concettualmente questo approccio è buono?

[gomo]

Scuste ancora ma sto appena iniziando lo studio di java. Non mi è chiara una cosa: la classe "Cointainer" la devo costruire io oppure rappresenta la classe ArrayList?