Patrón Prototype

Crea objetos nuevos copiando uno ya configurado (el prototipo) en lugar de construirlos desde cero: plantillas de documentos, enemigos de un juego. La clave es que la copia sea profunda.

nivel intermedioTambién: prototipo, clonar, clone, copia profunda

Visualízalo paso a paso

Cambia los datos, dale a reproducir y sigue cada paso en el dibujo, en la línea de Java que se ejecuta y en sus variables.

Prototype

Elige cómo se copia la plantilla del acta y qué secciones se añaden a la copia, separadas por comas.

Velocidad

Paso 1

La plantilla del acta ya está configurada. Para un acta nueva no se empieza de cero: se le pide una copia.

1Documento acta = plantilla.copia();  // copia = profunda, listas = 1
2acta.secciones.add("Ruegos y preguntas");
3
4Documento copia() {
5    return new Documento(titulo, secciones);
6}
7
8Documento(String titulo, List<String> secciones) {
9    this.titulo = titulo;
10    this.secciones = new ArrayList<>(secciones);
11}
12
13Documento copiaSuperficial() {
14    Documento d = new Documento(titulo, List.of());
15    d.secciones = secciones;
16    return d;
17}

Variables

copia: profunda
listas: 1

Atajos con el foco dentro del visualizador: ← → paso a paso, Espacio reproducir o pausar, Inicio/Fin ir al principio o al final.

La idea

Hay objetos que cuesta mucho configurar (una plantilla de documento con sus secciones, un enemigo con sus estadísticas y su inventario, un formulario con sus campos) y de los que se necesitan muchos parecidos. En lugar de repetir toda la configuración, se guarda uno ya preparado, el prototipo, y cada objeto nuevo es una copia suya que después se retoca.

El patrón pide que el propio objeto sepa copiarse (un método copia() o clone()), porque es el único que conoce todos sus campos, también los privados. A menudo se combina con un registro de prototipos: un Map de nombre a prototipo, y crear un objeto es pedir una copia del que toca.

La trampa está en la copia superficial: copiar un objeto que tiene una lista copia la referencia a la lista, no la lista. La copia y el original comparten entonces sus secciones, y cambiar una cambia la otra. Una copia profunda crea también copias de los objetos mutables que contiene, hasta el nivel que haga falta.

Cuándo usarlo

Crear un objeto desde cero es caro o largo (muchos pasos de configuración, datos leídos de un fichero o de la red) y hacen falta muchos parecidos.
Los objetos se diferencian en pocos valores de una configuración común (plantillas, enemigos de un tipo, piezas de un editor).
El programa debe crear objetos de clases que no conoce, a partir de ejemplos que le dan (un editor que duplica la figura seleccionada, sea cual sea).

Cuándo no

Si crear el objeto es barato y sencillo: un constructor es más claro.
Si el objeto tiene referencias circulares o recursos que no se pueden duplicar (conexiones abiertas, ficheros): copiar bien es difícil y propenso a errores.

Participantes

Prototipo. La clase con el método de copia (copia() o clone()), que crea un objeto nuevo con los mismos valores y copias propias de sus partes mutables.
Registro de prototipos. Opcional: un Map de nombre a prototipo ya configurado (plantillas).
Cliente. Pide una copia del prototipo y la retoca (cambia el título, añade una sección) sin tocar el original.

Diagrama de clases

Arrastra las clases para colocarlas a tu gusto.

Ver el diagrama en PlantUML

text

1@startuml
2class Documento {
3  -titulo : String
4  -secciones : List<String>
5  +Documento(titulo : String, secciones : List<String>)
6  +copia() : Documento
7}
8class Plantillas {
9  -prototipos : Map<String, Documento>
10  +registrar(nombre : String, d : Documento) : void
11  +crear(nombre : String) : Documento
12}
13class Cliente
14Plantillas o-- "0..*" Documento : prototipos
15Cliente ..> Plantillas : crear()
16@enduml

Puedes copiarlo en el editor de diagramas UML y modificarlo.

El código

Plantillas de documentos

La copia profunda deja la plantilla intacta; la superficial comparte la lista y la estropea.

Java
import java.util.*;

/** El prototipo: un documento ya configurado que sabe hacer una copia de sí mismo. */
class Documento {
    String titulo;
    List<String> secciones;

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

    /** Copia profunda: la copia tiene su propia lista de secciones. */
    Documento copia() {
        return new Documento(titulo, secciones);          // el constructor copia la lista
    }

    /** Copia superficial (el error típico): la copia comparte la lista con el original. */
    Documento copiaSuperficial() {
        Documento d = new Documento(titulo, List.of());
        d.secciones = secciones;
        return d;
    }

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

public class Main {
    public static void main(String[] args) {
        // Un registro de prototipos: crear un documento es copiar una plantilla ya configurada
        Map<String, Documento> plantillas = new LinkedHashMap<>();
        plantillas.put("acta", new Documento("Acta de reunión", List.of("Asistentes", "Orden del día", "Acuerdos")));
        plantillas.put("informe", new Documento("Informe técnico", List.of("Resumen", "Análisis", "Conclusiones")));

        Documento acta = plantillas.get("acta").copia();
        acta.titulo = "Acta del 3 de octubre";
        acta.secciones.add("Ruegos y preguntas");
        System.out.println("Copia: " + acta);
        System.out.println("Plantilla: " + plantillas.get("acta"));

        Documento informe = plantillas.get("informe").copiaSuperficial();
        informe.secciones.add("Anexo");
        System.out.println("Plantilla tras una copia superficial: " + plantillas.get("informe"));
    }
}

class Documento:
    """El prototipo: un documento ya configurado que sabe hacer una copia de sí mismo."""

    def __init__(self, titulo, secciones):
        self.titulo = titulo
        self.secciones = list(secciones)

    def copia(self):
        """Copia profunda: la copia tiene su propia lista de secciones."""
        return Documento(self.titulo, self.secciones)     # el constructor copia la lista

    def copia_superficial(self):
        """Copia superficial (el error típico): la copia comparte la lista con el original."""
        d = Documento(self.titulo, [])
        d.secciones = self.secciones
        return d

    def __str__(self):
        return f"{self.titulo} [{', '.join(self.secciones)}]"


# Un registro de prototipos: crear un documento es copiar una plantilla ya configurada
plantillas = {
    "acta": Documento("Acta de reunión", ["Asistentes", "Orden del día", "Acuerdos"]),
    "informe": Documento("Informe técnico", ["Resumen", "Análisis", "Conclusiones"]),
}

acta = plantillas["acta"].copia()
acta.titulo = "Acta del 3 de octubre"
acta.secciones.append("Ruegos y preguntas")
print(f"Copia: {acta}")
print(f"Plantilla: {plantillas['acta']}")

informe = plantillas["informe"].copia_superficial()
informe.secciones.append("Anexo")
print(f"Plantilla tras una copia superficial: {plantillas['informe']}")

/** El prototipo: un documento ya configurado que sabe hacer una copia de sí mismo. */
class Documento {
    constructor(titulo, secciones) {
        this.titulo = titulo;
        this.secciones = [...secciones];
    }

    /** Copia profunda: la copia tiene su propia lista de secciones. */
    copia() {
        return new Documento(this.titulo, this.secciones);   // el constructor copia la lista
    }

    /** Copia superficial (el error típico): la copia comparte la lista con el original. */
    copiaSuperficial() {
        const d = new Documento(this.titulo, []);
        d.secciones = this.secciones;
        return d;
    }

    toString() { return `${this.titulo} [${this.secciones.join(", ")}]`; }
}

// Un registro de prototipos: crear un documento es copiar una plantilla ya configurada
const plantillas = new Map([
    ["acta", new Documento("Acta de reunión", ["Asistentes", "Orden del día", "Acuerdos"])],
    ["informe", new Documento("Informe técnico", ["Resumen", "Análisis", "Conclusiones"])],
]);

const acta = plantillas.get("acta").copia();
acta.titulo = "Acta del 3 de octubre";
acta.secciones.push("Ruegos y preguntas");
console.log(`Copia: ${acta}`);
console.log(`Plantilla: ${plantillas.get("acta")}`);

const informe = plantillas.get("informe").copiaSuperficial();
informe.secciones.push("Anexo");
console.log(`Plantilla tras una copia superficial: ${plantillas.get("informe")}`);

using System;
using System.Collections.Generic;

// El prototipo: un documento ya configurado que sabe hacer una copia de sí mismo.
class Documento {
    public string Titulo;
    public List<string> Secciones;

    public Documento(string titulo, IEnumerable<string> secciones) {
        Titulo = titulo;
        Secciones = new List<string>(secciones);
    }

    // Copia profunda: la copia tiene su propia lista de secciones.
    public Documento Copia() => new(Titulo, Secciones);   // el constructor copia la lista

    // Copia superficial (el error típico): la copia comparte la lista con el original.
    public Documento CopiaSuperficial() => (Documento)MemberwiseClone();

    public override string ToString() => quot;{Titulo} [{string.Join(", ", Secciones)}]";
}

class Program {
    static void Main() {
        // Un registro de prototipos: crear un documento es copiar una plantilla ya configurada
        var plantillas = new Dictionary<string, Documento> {
            ["acta"] = new("Acta de reunión", new[] { "Asistentes", "Orden del día", "Acuerdos" }),
            ["informe"] = new("Informe técnico", new[] { "Resumen", "Análisis", "Conclusiones" }),
        };

        Documento acta = plantillas["acta"].Copia();
        acta.Titulo = "Acta del 3 de octubre";
        acta.Secciones.Add("Ruegos y preguntas");
        Console.WriteLine(quot;Copia: {acta}");
        Console.WriteLine(quot;Plantilla: {plantillas["acta"]}");

        Documento informe = plantillas["informe"].CopiaSuperficial();
        informe.Secciones.Add("Anexo");
        Console.WriteLine(quot;Plantilla tras una copia superficial: {plantillas["informe"]}");
    }
}

<?php
/**
 * El prototipo: un documento ya configurado que sabe hacer una copia de sí mismo.
 * Las secciones van en un ArrayObject porque los arrays de PHP se copian al asignarlos;
 * los objetos, en cambio, se comparten, como en Java.
 */
class Documento {
    public ArrayObject $secciones;

    public function __construct(public string $titulo, array $secciones) {
        $this->secciones = new ArrayObject($secciones);
    }

    /** Copia profunda: la copia tiene su propia lista de secciones. */
    public function copia(): Documento {
        return new Documento($this->titulo, $this->secciones->getArrayCopy());
    }

    /** Copia superficial (el error típico): clone copia campo a campo y comparte la lista. */
    public function copiaSuperficial(): Documento {
        return clone $this;
    }

    public function __toString(): string {
        return $this->titulo . " [" . implode(", ", $this->secciones->getArrayCopy()) . "]";
    }
}

// Un registro de prototipos: crear un documento es copiar una plantilla ya configurada
$plantillas = [
    "acta" => new Documento("Acta de reunión", ["Asistentes", "Orden del día", "Acuerdos"]),
    "informe" => new Documento("Informe técnico", ["Resumen", "Análisis", "Conclusiones"]),
];

$acta = $plantillas["acta"]->copia();
$acta->titulo = "Acta del 3 de octubre";
$acta->secciones->append("Ruegos y preguntas");
echo "Copia: $acta\n";
echo "Plantilla: {$plantillas["acta"]}\n";

$informe = $plantillas["informe"]->copiaSuperficial();
$informe->secciones->append("Anexo");
echo "Plantilla tras una copia superficial: {$plantillas["informe"]}\n";

Salida al ejecutarlo (la misma en los 5 lenguajes)

Copia: Acta del 3 de octubre [Asistentes, Orden del día, Acuerdos, Ruegos y preguntas]
Plantilla: Acta de reunión [Asistentes, Orden del día, Acuerdos]
Plantilla tras una copia superficial: Informe técnico [Resumen, Análisis, Conclusiones, Anexo]

clone() y el constructor de copia

Cómo se copia en cada lenguaje, y la diferencia entre la copia superficial que da el lenguaje y la profunda que hay que escribir.

Java
/** Con clone(): Object.clone copia campo a campo, y los objetos mutables se copian a mano. */
class Documento implements Cloneable {
    String titulo;
    ArrayList<String> secciones = new ArrayList<>();

    @Override
    public Documento clone() {
        try {
            Documento copia = (Documento) super.clone();      // copia superficial de todos los campos
            copia.secciones = new ArrayList<>(secciones);      // y una lista nueva para la copia
            return copia;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(e);                       // no pasa: la clase implementa Cloneable
        }
    }
}

// Effective Java recomienda un constructor de copia o un método copia() en lugar de clone():
// no hace falta Cloneable, no hay excepciones ni casts y funciona con campos final.
Documento copia = new Documento(original);

import copy

original = Documento("Informe técnico", ["Resumen", "Análisis"])
superficial = copy.copy(original)      # un objeto nuevo... que comparte la lista
profunda = copy.deepcopy(original)     # copia también todo lo que contiene, a cualquier profundidad

# Una clase puede decidir cómo se copia definiendo __copy__ y __deepcopy__.

const original = { titulo: "Informe técnico", secciones: ["Resumen", "Análisis"] };
const superficial = { ...original };            // un objeto nuevo... que comparte la lista
const profunda = structuredClone(original);     // copia todo (pero no funciones ni clases)

// En JavaScript los objetos heredan de prototipos de verdad:
const plantilla = { idioma: "es", saludar() { return "Hola"; } };
const doc = Object.create(plantilla);           // doc no copia nada: busca en plantilla lo que no tiene

class Documento : ICloneable {
    public string Titulo = "";
    public List<string> Secciones = new();

    // MemberwiseClone copia campo a campo (superficial); la lista se copia a mano
    public Documento Copia() {
        var copia = (Documento)MemberwiseClone();
        copia.Secciones = new List<string>(Secciones);
        return copia;
    }

    object ICloneable.Clone() => Copia();
}

// Los record traen una copia con cambios (también superficial):
record Plantilla(string Titulo, int Version);
var nueva = plantilla with { Version = 2 };

<?php
class Documento {
    public function __construct(public string $titulo, public ArrayObject $secciones) {}

    // clone copia el objeto campo a campo (superficial); __clone se ejecuta sobre la copia
    // para duplicar a mano lo que no se debe compartir.
    public function __clone() {
        $this->secciones = new ArrayObject($this->secciones->getArrayCopy());
    }
}

$copia = clone $original;

// Ojo: los arrays de PHP se copian al asignarlos (nunca se comparten); los objetos no.

En la práctica

clone() de los arrays y de ArrayList en Java (ojo: superficial), copy.deepcopy en Python y structuredClone en JavaScript.
Los editores (de diagramas, de niveles de un juego, de presentaciones): «duplicar» copia el elemento seleccionado sea cual sea su clase.
Los motores de juegos instancian enemigos y objetos a partir de prefabs: Unity llama Instantiate(prefab) a copiar un prototipo.
En JavaScript todo el sistema de objetos se basa en prototipos: Object.create(proto) crea un objeto que hereda de otro.

Errores típicos

Hacer una copia superficial de un objeto con listas o mapas: la copia y el original comparten los datos y los cambios se cuelan de uno a otro.
Copiar la lista pero no los objetos mutables de dentro: la lista es nueva, pero sus elementos siguen siendo los mismos (la copia tiene que bajar todos los niveles mutables).
Devolver this en copia(): no hay copia, solo otra referencia al mismo objeto.
Usar clone() sin implementar Cloneable (lanza CloneNotSupportedException) o olvidar que Object.clone es superficial.

Ejercicios

Cada ejercicio se corrige solo con sus pruebas (algunas ocultas). Escribe tu solución en el editor y pulsa Ejecutar o Comprobar; la solución explicada está debajo, por si te atascas.

1. Enemigos a partir de prototipos

Cada enemigo nuevo se crea copiando el prototipo de su tipo y poniéndole nombre. Pero copia() devuelve el propio prototipo: al crear dos orcos, los dos son el mismo objeto, y lo que le pasa a uno le pasa al otro (y al prototipo). Escribe copia() para que cree un enemigo independiente, con su propia lista de objetos.

Órdenes: crear tipo nombre (orco, arquero o troll), dar nombre objeto, golpear nombre daño, ver nombre y prototipo tipo. Al final, Quedan N enemigos en pie.
Los mensajes ya están escritos: solo falta que cada copia sea independiente del prototipo y de las demás copias.

JavaEnemigos a partir de prototiposFácil

Ejemplo

Entrada (lo que se escribe por teclado)

crear orco Grishnak
crear orco Ugluk
dar Grishnak pocion
golpear Ugluk 12
ver Grishnak
ver Ugluk
prototipo orco

Salida esperada

Creado: Grishnak (orco)
Creado: Ugluk (orco)
Grishnak recibe pocion
Ugluk: vida 18
Grishnak (orco): vida 30, ataque 5, objetos [hacha, pocion]
Ugluk (orco): vida 18, ataque 5, objetos [hacha]
Prototipo orco (orco): vida 30, ataque 5, objetos [hacha]
Quedan 2 enemigos en pie

Dos orcos independientes

Tipos, nombres y órdenes que no valen

Test oculto #3

Test oculto #4

0/4 tests pasados · pulsa un test para ver su entrada y su salida esperada

Ver la solución explicada

java
import java.util.*;

/** Un enemigo del juego. Los nuevos se crean copiando un prototipo ya configurado. */
class Enemigo {
    final String tipo;
    String nombre;
    int vida;
    final int ataque;
    List<String> objetos;

    Enemigo(String tipo, int vida, int ataque, List<String> objetos) {
        this.tipo = tipo;
        this.nombre = tipo;
        this.vida = vida;
        this.ataque = ataque;
        this.objetos = new ArrayList<>(objetos);
    }

    /** Una copia independiente: cambiar la copia no cambia el prototipo ni las demás copias. */
    Enemigo copia() {
        Enemigo e = new Enemigo(tipo, vida, ataque, objetos);   // el constructor copia la lista
        e.nombre = nombre;
        return e;
    }

    String ficha() {
        return nombre + " (" + tipo + "): vida " + vida + ", ataque " + ataque + ", objetos " + objetos;
    }
}

public class Main {
    public static void main(String[] args) {
        Map<String, Enemigo> prototipos = new HashMap<>();
        prototipos.put("orco", new Enemigo("orco", 30, 5, List.of("hacha")));
        prototipos.put("arquero", new Enemigo("arquero", 20, 7, List.of("arco", "flechas")));
        prototipos.put("troll", new Enemigo("troll", 80, 12, List.of("garrote")));

        Map<String, Enemigo> enemigos = new LinkedHashMap<>();
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String[] p = sc.nextLine().trim().split("\\s+");
            if (p[0].isEmpty()) continue;
            String orden = p[0] + "/" + (p.length - 1);
            Enemigo e = p.length > 1 && !p[0].equals("crear") && !p[0].equals("prototipo") ? enemigos.get(p[1]) : null;
            if (e == null && p.length > 1 && (p[0].equals("dar") || p[0].equals("golpear") || p[0].equals("ver"))) {
                System.out.println("No existe: " + p[1]);
                continue;
            }
            switch (orden) {
                case "crear/2" -> {
                    Enemigo proto = prototipos.get(p[1]);
                    if (proto == null) System.out.println("Tipo desconocido: " + p[1]);
                    else if (enemigos.containsKey(p[2])) System.out.println("Ya existe: " + p[2]);
                    else {
                        Enemigo nuevo = proto.copia();
                        nuevo.nombre = p[2];
                        enemigos.put(p[2], nuevo);
                        System.out.println("Creado: " + p[2] + " (" + p[1] + ")");
                    }
                }
                case "dar/2" -> {
                    e.objetos.add(p[2]);
                    System.out.println(e.nombre + " recibe " + p[2]);
                }
                case "golpear/2" -> {
                    try {
                        e.vida = Math.max(0, e.vida - Integer.parseInt(p[2]));
                        System.out.println(e.vida == 0 ? e.nombre + " ha caído" : e.nombre + ": vida " + e.vida);
                    } catch (NumberFormatException ex) {
                        System.out.println("Orden no válida: " + String.join(" ", p));
                    }
                }
                case "ver/1" -> System.out.println(e.ficha());
                case "prototipo/1" -> {
                    Enemigo proto = prototipos.get(p[1]);
                    System.out.println(proto == null ? "Tipo desconocido: " + p[1] : "Prototipo " + proto.ficha());
                }
                default -> System.out.println("Orden no válida: " + String.join(" ", p));
            }
        }
        System.out.println("Quedan " + enemigos.values().stream().filter(x -> x.vida > 0).count() + " enemigos en pie");
    }
}

return this no copia nada: devuelve otra referencia al mismo objeto, y todos los «orcos» eran el prototipo con distintos nombres sucesivos.

La copia profunda crea una lista nueva: dar un objeto a un enemigo ya no se lo da a todos los de su tipo.

2. Formularios a partir de plantillas

Los formularios se crean copiando una plantilla (nuevo) o un formulario que ya existe (duplicar), y luego se rellenan. La copia actual crea una lista nueva pero mete en ella los mismos objetos Campo, así que rellenar un formulario rellena también la plantilla y todas sus copias. Haz que la copia sea profunda de verdad: añade copia() a Campo y úsalo en Formulario.copia().

Órdenes: nuevo plantilla nombre, duplicar formulario nombre, rellenar nombre campo valor (el valor puede tener espacios), obligatorio nombre campo, ver nombre y enviar nombre.
ver escribe nombre (plantilla): campo = valor · ..., con * tras los obligatorios y (vacío) si no tienen valor. enviar escribe Enviado: nombre o Falta: campos obligatorios vacíos.

JavaFormularios a partir de plantillasMedio