Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Costruttore di copia, copia superficiale e copia profonda

Un costruttore di copia crea una nuova istanza da una esistente. La copia superficiale condivide ancora gli oggetti annidati; quella profonda separa lo stato mutabile previsto dal contratto di copia.

Versione: Java SE 21

Sintassi

T(T source) { /* initialize the new instance from source */ }
T copy = new T(source);

Un costruttore di copia è un normale costruttore che riceve un’istanza della stessa classe, come T(T source). Java SE 21 non lo genera automaticamente. In new T(source), il costruttore da usare tra quelli sovraccaricati viene scelto in fase di compilazione; l’implementazione decide cosa copiare e cosa condividere. Invece T alias = source copia solo il riferimento, senza creare un oggetto.

Una copia superficiale crea un nuovo oggetto esterno, ma copia i valori dei campi così come sono, sia quelli primitivi sia i riferimenti. Una modifica a un oggetto mutabile condiviso è visibile da entrambe le istanze. Un campo riferimento final impedisce la riassegnazione, non la modifica dell’oggetto a cui si riferisce. L’implementazione di base di Object.clone() esegue una copia superficiale e lancia CloneNotSupportedException se l’oggetto non implementa Cloneable. Un costruttore di copia non richiede questa interfaccia.

Una copia profonda ricrea anche gli oggetti mutabili annidati previsti dal contratto di copia. Le modifiche a questo stato non si propagano tra l’originale e la copia. Gli oggetti immutabili possono essere condivisi. Un nuovo contenitore non basta se i suoi elementi mutabili sono ancora condivisi.

Per preservare i cicli e i nodi condivisi di un grafo di oggetti, registra ogni coppia originale–copia in base all’identità degli oggetti, per esempio in una IdentityHashMap, prima di seguire i riferimenti del nodo. I riferimenti allo stesso nodo raggiungono così la stessa copia e i cicli non causano ricorsione infinita.

Esempi

public class Main {
    static final class Box {
        private final int[] values;

        private Box(int[] values) {
            this.values = values;
        }

        Box(Box source) {
            this(source.values.clone());
        }

        static Box shallowCopyOf(Box source) {
            return new Box(source.values);
        }
    }

    public static void main(String[] args) {
        Box original = new Box(new int[] {1});
        Box shallow = Box.shallowCopyOf(original);
        Box deep = new Box(original);

        System.out.println("Distinct boxes: " + (original != shallow) + ", " + (original != deep));
        System.out.println("Shared arrays: " + (original.values == shallow.values)
                + ", " + (original.values == deep.values));

        shallow.values[0] = 7;
        deep.values[0] = 9;
        System.out.println("Values: original=" + original.values[0]
                + ", shallow=" + shallow.values[0] + ", deep=" + deep.values[0]);
    }
}

Risultato

Distinct boxes: true, true
Shared arrays: true, false
Values: original=7, shallow=7, deep=9

Entrambe le copie sono nuovi oggetti `Box`; solo `shallow` condivide il suo array con `original`. Una modifica tramite `shallow` imposta a `7` il valore visibile in `original`, mentre una modifica tramite `deep` imposta solo il proprio valore a `9`. Clonare un `int[]` è sufficiente perché gli elementi sono primitivi; clonare un array di riferimenti non copia gli oggetti referenziati.

Lezioni correlate

  • Java · Lezione 6 · Avanzato · Versione: 2

Fonti