KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Kopieerconstructor, oppervlakkige en diepe kopieën

Een kopieerconstructor maakt van een bestaande instantie een nieuwe. Een oppervlakkige kopie deelt nog geneste objecten; een diepe kopie scheidt de veranderlijke toestand die onder het kopieercontract valt.

Versie: Java SE 21

Syntax

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

Een kopieerconstructor is een gewone constructor die een instantie van dezelfde klasse aanneemt, bijvoorbeeld T(T source). Java SE 21 genereert die niet automatisch. Bij new T(source) wordt tijdens compilatie bepaald welke overbelaste constructor wordt aangeroepen; de implementatie bepaalt wat wordt gekopieerd of gedeeld. T alias = source kopieert daarentegen alleen de referentie en maakt geen object aan.

Een oppervlakkige kopie maakt een nieuw buitenste object, maar neemt de veldwaarden ongewijzigd over: zowel primitieve waarden als referenties. Een wijziging aan een gedeeld veranderlijk object is via beide instanties zichtbaar. Een final-referentieveld verhindert hertoewijzing, niet het wijzigen van het object waarnaar het verwijst. De basisimplementatie van Object.clone() maakt een oppervlakkige kopie en gooit CloneNotSupportedException als het object Cloneable niet implementeert. Een kopieerconstructor heeft die interface niet nodig.

Een diepe kopie maakt ook nieuwe exemplaren van de geneste veranderlijke objecten die onder het kopieercontract vallen. Wijzigingen aan die toestand werken niet door tussen origineel en kopie. Onveranderlijke objecten mogen worden gedeeld. Alleen een nieuwe container is niet genoeg als de veranderlijke elementen gedeeld blijven.

Wil je cycli en gedeelde knopen in een objectgraaf behouden, leg dan elk paar van origineel en kopie vast op basis van objectidentiteit, bijvoorbeeld in een IdentityHashMap, voordat je de referenties van die knoop volgt. Meerdere referenties naar dezelfde knoop komen zo uit bij dezelfde kopie en cycli veroorzaken geen oneindige recursie.

Voorbeelden

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

Resultaat

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

Beide kopieën zijn nieuwe `Box`-objecten; alleen `shallow` deelt zijn array met `original`. Een wijziging via `shallow` zet de waarde die in `original` zichtbaar is op `7`, terwijl een wijziging via `deep` alleen zijn eigen waarde op `9` zet. Een `int[]` klonen volstaat omdat de elementen primitief zijn; bij het klonen van een referentiearray worden de objecten waarnaar die verwijst niet gekopieerd.

Gerelateerde lessen

  • Java · Les 6 · Gevorderd · Versie: 2

Bronnen