Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

Kopirni konstruktor, plitvo in globoko kopiranje

Kopirni konstruktor ustvari nov primerek iz obstoječega. Plitva kopija si še vedno deli vgnezdene objekte, globoka pa loči spremenljivo stanje, ki ga zajema pogodba kopiranja.

Različica: Java SE 21

Sintaksa

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

Kopirni konstruktor je običajen konstruktor, ki sprejme primerek istega razreda, na primer T(T source). Java SE 21 ga ne ustvari samodejno. Pri new T(source) se preobremenjena različica konstruktorja izbere med prevajanjem, izvedba pa določa, kaj se kopira in kaj se deli. Nasprotno T alias = source kopira le referenco in ne ustvari objekta.

Plitva kopija ustvari nov zunanji objekt, a nespremenjeno prevzame vrednosti polj, tako primitivne vrednosti kot reference. Sprememba skupnega spremenljivega objekta je vidna prek obeh primerkov. Referenčno polje final prepreči dodelitev druge reference, ne pa spremembe objekta, na katerega kaže. Osnovna izvedba Object.clone() naredi plitvo kopijo in sproži CloneNotSupportedException, če objekt ne implementira Cloneable. Kopirni konstruktor tega vmesnika ne potrebuje.

Globoka kopija na novo ustvari tudi vgnezdene spremenljive objekte, ki jih zajema pogodba kopiranja. Spremembe tega stanja se med izvirnikom in kopijo ne prenašajo. Nespremenljive objekte je mogoče deliti. Nov vsebnik sam po sebi ni dovolj, če so njegovi spremenljivi elementi še vedno skupni.

Če želiš v grafu objektov ohraniti cikle in skupna vozlišča, shrani vsak par izvirnik–kopija po identiteti objektov, na primer v IdentityHashMap, preden slediš referencam iz vozlišča. Več referenc na isto vozlišče tako vodi do iste kopije, cikli pa ne povzročijo neskončne rekurzije.

Primeri

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

Rezultat

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

Obe kopiji sta nova objekta `Box`; le `shallow` si deli tabelo z `original`. Sprememba prek `shallow` nastavi vrednost, vidno v `original`, na `7`, sprememba prek `deep` pa nastavi le njegovo lastno vrednost na `9`. Kloniranje `int[]` zadošča, ker so elementi primitivne vrednosti; kloniranje tabele referenc ne kopira objektov, na katere kažejo.

Povezane lekcije

  • Java · Lekcija 6 · Napredna · Različica: 2

Viri