Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Kopírovací konstruktor, mělká a hluboká kopie

Kopírovací konstruktor vytváří novou instanci z existující. Mělká kopie nadále sdílí vnořené objekty, zatímco hluboká odděluje měnitelný stav vymezený smlouvou o kopírování.

Verze: Java SE 21

Syntaxe

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

Kopírovací konstruktor je běžný konstruktor, který přijímá instanci stejné třídy, například T(T source). Java SE 21 jej nevytváří automaticky. U new T(source) se varianta přetíženého konstruktoru vybírá při kompilaci; implementace určuje, co se kopíruje a co se sdílí. Naproti tomu T alias = source zkopíruje pouze referenci a nevytvoří nový objekt.

Mělká kopie vytvoří nový vnější objekt, ale převezme hodnoty polí beze změny: jak primitivní hodnoty, tak reference. Změna sdíleného měnitelného objektu je viditelná přes obě instance. Referenční pole final nedovolí přiřadit jinou referenci, ale nebrání změně odkazovaného objektu. Základní implementace Object.clone() vytvoří mělkou kopii a vyvolá CloneNotSupportedException, pokud objekt neimplementuje Cloneable. Kopírovací konstruktor toto rozhraní nepotřebuje.

Hluboká kopie vytvoří také nové vnořené měnitelné objekty v rozsahu stanoveném smlouvou o kopírování. Změny tohoto stavu se mezi originálem a kopií nepřenášejí. Neměnné objekty lze sdílet. Samotný nový kontejner nestačí, pokud jsou jeho měnitelné prvky stále sdílené.

Chceš-li zachovat cykly a sdílené uzly v grafu objektů, ulož dvojici originál–kopie podle identity objektů, například do IdentityHashMap, dříve, než začneš sledovat reference z daného uzlu. Opakované odkazy na tentýž uzel pak vedou k jediné kopii a cykly nezpůsobí nekonečnou rekurzi.

Příklady

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

Výsledek

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

Obě kopie jsou nové objekty `Box`; pouze `shallow` sdílí pole s `original`. Změna přes `shallow` nastaví hodnotu viditelnou v `original` na `7`, zatímco změna přes `deep` nastaví pouze jeho vlastní hodnotu na `9`. Klonování `int[]` stačí, protože prvky jsou primitivní hodnoty; klonování pole referencí nekopíruje odkazované objekty.

Související lekce

  • Java · Lekce 6 · Pokročilá · Verze: 2

Zdroje