Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Konstruktor kopiujący, kopiowanie płytkie i głębokie

Konstruktor kopiujący tworzy nową instancję na podstawie istniejącej. Kopia płytka nadal współdzieli zagnieżdżone obiekty, a głęboka oddziela mutowalny stan objęty kontraktem kopiowania.

Wersja: Java SE 21

Składnia

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

Konstruktor kopiujący to zwykły konstruktor przyjmujący instancję tej samej klasy, np. T(T source). Java SE 21 nie tworzy go automatycznie. W new T(source) przeciążenie jest wybierane w czasie kompilacji, a implementacja konstruktora określa, co kopiować, a co współdzielić. Samo T alias = source kopiuje tylko referencję, bez tworzenia nowego obiektu.

Kopia płytka ma nowy obiekt zewnętrzny, ale przejmuje wartości pól: zarówno wartości typów prymitywnych, jak i referencje. Zmianę współdzielonego obiektu mutowalnego widać z obu instancji. final w polu referencyjnym blokuje zmianę referencji, nie zmianę wskazywanego obiektu. Bazowa implementacja Object.clone() wykonuje kopię płytką i zgłasza CloneNotSupportedException, gdy obiekt nie implementuje Cloneable. Konstruktor kopiujący nie wymaga tego interfejsu.

Kopia głęboka odtwarza również zagnieżdżone obiekty mutowalne w granicach kontraktu kopiowania, tak by zmiany tego stanu nie przechodziły między oryginałem a kopią. Obiekty niemutowalne można współdzielić. Nowy kontener nie wystarczy, jeśli jego mutowalne elementy nadal są współdzielone.

Jeśli kopia ma zachować cykle i współdzielenie w grafie obiektów, zapisuj parę oryginał–kopia według tożsamości, np. w IdentityHashMap, zanim zaczniesz podążać za referencjami danego węzła. Dzięki temu odwołania do tego samego węzła trafiają do jednej kopii, a cykle nie powodują nieskończonej rekurencji.

Przykłady

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]);
    }
}

Wynik

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

Obie kopie są nowymi obiektami `Box`; tylko `shallow` współdzieli tablicę z `original`. Zmiana przez `shallow` ustawia wartość widoczną w `original` na `7`, a zmiana przez `deep` ustawia wyłącznie jego wartość na `9`. Klonowanie `int[]` wystarcza, bo elementy są prymitywne; klonowanie tablicy referencji nie kopiuje wskazywanych obiektów.

Powiązane lekcje

  • Java · Lekcja 6 · Zaawansowany · Wersja: 2

Źródła