CKTIS / Java
Constructor de copia, copia superficial y copia profunda
Un constructor de copia crea una instancia nueva a partir de otra. La copia superficial sigue compartiendo objetos anidados; la profunda separa el estado mutable cubierto por el contrato de copia.
Versión: Java SE 21
Sintaxis
T(T source) { /* initialize the new instance from source */ }
T copy = new T(source);Un constructor de copia es un constructor ordinario que recibe una instancia de la misma clase, como T(T source). Java SE 21 no lo genera automáticamente. En new T(source), la sobrecarga se selecciona en tiempo de compilación, y la implementación decide qué se copia y qué se comparte. En cambio, T alias = source solo copia la referencia, sin crear ningún objeto.
Una copia superficial crea un objeto externo nuevo, pero conserva tal cual los valores de los campos, tanto los primitivos como las referencias. Un cambio en un objeto mutable compartido se observa desde ambas instancias. Un campo de referencia final impide reasignar la referencia, no modificar el objeto referenciado. La implementación base de Object.clone() realiza una copia superficial y lanza CloneNotSupportedException si el objeto no implementa Cloneable. Un constructor de copia no necesita esa interfaz.
Una copia profunda también recrea los objetos mutables anidados cubiertos por el contrato de copia. Los cambios en ese estado no se propagan entre el original y la copia. Los objetos inmutables se pueden compartir. Un contenedor nuevo no basta si sus elementos mutables siguen compartidos.
Para conservar los ciclos y los nodos compartidos de un grafo de objetos, registra cada pareja de original y copia por identidad, por ejemplo en un IdentityHashMap, antes de seguir las referencias del nodo. Así, varias referencias al mismo nodo apuntan a una sola copia y los ciclos no provocan recursión infinita.
Ejemplos
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]);
}
}Resultado
Distinct boxes: true, true Shared arrays: true, false Values: original=7, shallow=7, deep=9
Las dos copias son objetos `Box` nuevos; solo `shallow` comparte su array con `original`. Modificarlo a través de `shallow` cambia a `7` el valor visible en `original`, mientras que modificarlo a través de `deep` solo cambia su propio valor a `9`. Clonar un `int[]` basta porque sus elementos son primitivos; clonar un array de referencias no copia los objetos referenciados.
Lecciones relacionadas
- Java · Lección 6 · Avanzado · Versión: 2