Artículo

Patrón Prototype en Java: clonar objetos con copia profunda

Qué es el patrón Prototype en Java: clonar objetos con un constructor de copia, copia superficial frente a profunda y por qué evitar clone().

En resumen: el patrón Prototype crea objetos nuevos copiando uno existente (el prototipo) en lugar de construirlos desde cero. Es útil cuando montar el objeto es caro o tiene muchos valores por defecto. En Java, implementa la copia con un constructor de copia o un método copiar(), y haz copia profunda de los campos mutables (listas, mapas, objetos): si no, el original y la copia comparten estado. Evita Object.clone(). Probado con Java 25, compatible desde Java 17.

Vídeo explicativo

Implementación con registro de prototipos

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

class Documento {
    private final String plantilla;
    private String titulo;
    private final List<String> secciones;

    Documento(String plantilla, String titulo, List<String> secciones) {
        this.plantilla = plantilla;
        this.titulo = titulo;
        this.secciones = secciones;
    }

    // Constructor de copia: copia profunda de la lista mutable
    Documento(Documento otro) {
        this(otro.plantilla, otro.titulo, new ArrayList<>(otro.secciones));
    }

    Documento copiar() {
        return new Documento(this);
    }

    void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    void anadirSeccion(String s) {
        secciones.add(s);
    }

    @Override
    public String toString() {
        return "[" + plantilla + "] " + titulo + " " + secciones;
    }
}

class RegistroPrototipos {
    private final Map<String, Documento> prototipos = new HashMap<>();

    void registrar(String clave, Documento d) {
        prototipos.put(clave, d);
    }

    Documento crear(String clave) {
        Documento p = prototipos.get(clave);
        if (p == null) {
            throw new IllegalArgumentException("No hay prototipo " + clave);
        }
        return p.copiar();
    }
}

public class Main {
    public static void main(String[] args) {
        RegistroPrototipos registro = new RegistroPrototipos();
        registro.registrar("informe", new Documento("corporativa", "Informe",
                new ArrayList<>(List.of("Resumen", "Datos", "Conclusiones"))));

        Documento q1 = registro.crear("informe");
        q1.setTitulo("Informe Q1");
        q1.anadirSeccion("Anexo Q1");

        Documento q2 = registro.crear("informe");
        q2.setTitulo("Informe Q2");

        System.out.println(q1);
        System.out.println(q2);
        System.out.println("Prototipo intacto: " + registro.crear("informe"));
    }
}

Salida:

[corporativa] Informe Q1 [Resumen, Datos, Conclusiones, Anexo Q1]
[corporativa] Informe Q2 [Resumen, Datos, Conclusiones]
Prototipo intacto: [corporativa] Informe [Resumen, Datos, Conclusiones]

Añadir «Anexo Q1» a la primera copia no afectó ni a la segunda ni al prototipo, porque cada copia tiene su propia lista.

Copia superficial frente a profunda

Si el constructor de copia hiciera this(otro.plantilla, otro.titulo, otro.secciones), las copias compartirían la misma lista: el «Anexo Q1» aparecería en todos los documentos, incluido el prototipo. Es el error más común del patrón.

Copia superficialCopia profunda
Campos primitivos e inmutables (String)Se copianSe copian
Campos mutables (listas, objetos)Se comparte la referenciaSe crea una copia nueva
RiesgoCambios en una copia afectan a otrasNinguno, si se copia todo lo mutable

Tienes más ejemplos en copia superficial y profunda en Java. Recuerda que Java pasa las referencias por valor: lo explicamos en paso por valor o por referencia.

¿Y clone()?

Java tiene Cloneable y Object.clone(), pero tienen problemas conocidos: Cloneable no declara ningún método, clone() hace copia superficial por defecto, devuelve Object, lanza una excepción comprobada y se salta los constructores. Joshua Bloch recomienda en Effective Java usar constructores o métodos de fábrica de copia, como en el ejemplo.

Cuándo usarlo

  • Crear el objeto requiere cargar datos, consultar configuración o muchos pasos, y las variantes solo cambian algunos campos.
  • Quieres un catálogo de configuraciones predefinidas (plantillas de documento, perfiles de juego, datos de prueba).
  • La alternativa sería una jerarquía de subclases solo para cambiar valores iniciales.

Si los objetos son inmutables, a menudo no necesitas el patrón: compártelos directamente o usa métodos withX(...) que devuelvan una copia modificada, como hacen los records.

Preguntas frecuentes

¿Prototype o Builder?

Builder construye un objeto paso a paso desde cero; Prototype parte de uno ya construido y lo copia. Se pueden combinar: un builder inicializado desde un prototipo.

¿Qué tiene que ver con el scope prototype de Spring?

Solo el nombre: el scope prototype crea una instancia nueva cada vez que se pide el bean, pero no copia ninguna existente. Lo vemos en inversión de control en Spring.

¿Cómo copio objetos con grafos complejos?

Copia cada nivel mutable en su constructor de copia o serializa y deserializa (por ejemplo, con Jackson). Lo segundo es más lento pero cubre grafos profundos.

Sigue aprendiendo

El resto de patrones creacionales: Singleton, Factory y Builder. El diseño de clases con patrones se trabaja en el curso de Java intermedio.

patrón prototype patrones de diseño java clonar objetos copia profunda

Newsletter Semanal de Java

Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.

Sin spam. Cancela cuando quieras.

Compartir artículo