CKTIS / Java
Kopierkonstruktor, flache und tiefe Kopie
Ein Kopierkonstruktor erzeugt aus einer vorhandenen Instanz eine neue. Eine flache Kopie teilt weiterhin verschachtelte Objekte; eine tiefe Kopie trennt den laut Kopiervertrag erfassten veränderlichen Zustand.
Version: Java SE 21
Syntax
T(T source) { /* initialize the new instance from source */ }
T copy = new T(source);Ein Kopierkonstruktor ist ein gewöhnlicher Konstruktor, der eine Instanz derselben Klasse entgegennimmt, etwa T(T source). Java SE 21 erzeugt ihn nicht automatisch. Bei new T(source) wird die Überladung zur Compilezeit ausgewählt. Die Implementierung legt fest, was kopiert und was gemeinsam genutzt wird. T alias = source kopiert dagegen nur die Referenz und erzeugt kein Objekt.
Eine flache Kopie erzeugt ein neues äußeres Objekt, übernimmt die Feldwerte aber unverändert: sowohl primitive Werte als auch Referenzen. Änderungen an einem gemeinsam genutzten veränderlichen Objekt sind über beide Instanzen sichtbar. Ein final-Referenzfeld verhindert eine Neuzuweisung, nicht aber Änderungen am referenzierten Objekt. Die Basisimplementierung von Object.clone() erstellt eine flache Kopie und löst CloneNotSupportedException aus, wenn das Objekt Cloneable nicht implementiert. Ein Kopierkonstruktor benötigt diese Schnittstelle nicht.
Eine tiefe Kopie erstellt auch die vom Kopiervertrag erfassten verschachtelten veränderlichen Objekte neu. Änderungen an diesem Zustand wirken sich nicht auf die jeweils andere Version aus. Unveränderliche Objekte können gemeinsam genutzt werden. Ein neuer Container allein genügt nicht, wenn seine veränderlichen Elemente weiterhin gemeinsam genutzt werden.
Um Zyklen und gemeinsam referenzierte Knoten in einem Objektgraphen zu erhalten, speichere jedes Paar aus Original und Kopie anhand der Objektidentität, etwa in einer IdentityHashMap, bevor du den Referenzen des Knotens folgst. Mehrere Verweise auf denselben Knoten führen so zur selben Kopie, und Zyklen verursachen keine Endlosrekursion.
Beispiele
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]);
}
}Ergebnis
Distinct boxes: true, true Shared arrays: true, false Values: original=7, shallow=7, deep=9
Beide Kopien sind neue `Box`-Objekte; nur `shallow` teilt sein Array mit `original`. Die Änderung über `shallow` setzt den in `original` sichtbaren Wert auf `7`, während die Änderung über `deep` nur dessen eigenen Wert auf `9` setzt. Bei `int[]` genügt das Klonen, weil die Elemente primitiv sind. Das Klonen eines Referenzarrays kopiert nicht die referenzierten Objekte.
Zugehörige Lektionen
- Java · Lektion 6 · Fortgeschritten · Version: 2