CKTIS / Java
Constructeur de copie, copie superficielle et copie profonde
Un constructeur de copie crée une instance à partir d’une autre. Une copie superficielle partage encore les objets imbriqués, tandis qu’une copie profonde sépare l’état mutable couvert par le contrat de copie.
Version : Java SE 21
Syntaxe
T(T source) { /* initialize the new instance from source */ }
T copy = new T(source);Un constructeur de copie est un constructeur ordinaire qui prend une instance de la même classe, par exemple T(T source). Java SE 21 ne le génère pas automatiquement. Dans new T(source), la surcharge est choisie à la compilation, et l’implémentation décide quoi copier ou partager. À l’inverse, T alias = source copie uniquement la référence, sans créer d’objet.
Une copie superficielle crée un nouvel objet englobant, mais reprend les valeurs des champs telles quelles, qu’il s’agisse de valeurs primitives ou de références. La modification d’un objet mutable partagé est visible depuis les deux instances. Un champ de référence final empêche la réaffectation, pas la modification de l’objet référencé. L’implémentation de base de Object.clone() produit une copie superficielle et lève CloneNotSupportedException si l’objet n’implémente pas Cloneable. Un constructeur de copie n’exige pas cette interface.
Une copie profonde recrée aussi les objets mutables imbriqués couverts par le contrat de copie. Les modifications de cet état ne se propagent pas de l’original à la copie, ni dans l’autre sens. Les objets immuables peuvent rester partagés. Un nouveau conteneur ne suffit pas si ses éléments mutables restent partagés.
Pour préserver les cycles et les nœuds partagés d’un graphe d’objets, enregistre chaque association entre original et copie selon l’identité des objets, par exemple dans une IdentityHashMap, avant de suivre les références du nœud. Plusieurs références au même nœud mènent ainsi à la même copie, et les cycles ne provoquent pas de récursion infinie.
Exemples
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]);
}
}Résultat
Distinct boxes: true, true Shared arrays: true, false Values: original=7, shallow=7, deep=9
Les deux copies sont de nouveaux objets `Box` ; seul `shallow` partage son tableau avec `original`. La modification via `shallow` fixe à `7` la valeur visible dans `original`, tandis que la modification via `deep` fixe uniquement sa propre valeur à `9`. Cloner un `int[]` suffit parce que ses éléments sont primitifs ; cloner un tableau de références ne copie pas les objets référencés.
Leçons associées
- Java · Leçon 6 · Avancé · Version : 2