Prototype

El patrón de diseño de prototipo es un patrón de creación que permite la creación de nuevos objetos copiando un objeto existente. Prototype nos permite ocultar la complejidad de crear nuevas instancias al cliente. El concepto es copiar un objeto existente en lugar de crear una nueva instancia desde cero, algo que puede incluir operaciones costosas. El objeto existente actúa como prototipo y contiene el estado del objeto.

• El objeto recién copiado puede cambiar las propiedades sólo si es necesario. Este enfoque ahorra tiempo y recursos costosos, especialmente cuando la creación de objetos es un proceso pesado.
• Una de las mejores formas disponibles de crear un objeto a partir de objetos existentes es el método clone() . Clonar es el enfoque más simple para implementar un patrón prototipo. Sin embargo, es su decisión decidir cómo copiar los objetos existentes según su modelo de negocio.

Supongamos que un usuario crea un documento con un diseño, fuentes y estilos específicos y desea crear documentos similares con ligeras modificaciones.

En lugar de empezar desde cero, el usuario puede utilizar el patrón Prototipo. El documento original se convierte en el prototipo y se crean nuevos documentos clonando este prototipo. Este enfoque garantiza que los nuevos documentos hereden la estructura y el estilo del documento original y, al mismo tiempo, permite la personalización.

Components

Los componentes del Patrón de Diseño de Prototipo incluyen la interfaz de prototipo o clase abstracta, prototipos concretos y el código del cliente, y el método clone que especifica el comportamiento de clonación. Estos componentes trabajan juntos para permitir la creación de nuevos objetos copiando los existentes.

Interface or abstract class que representa el prototipo

public interface Shape {
    Shape clone();  // Make a copy of itself
    void draw();    // Draw the shape
}

// This is a specific shape, a circle, implementing the Shape interface.
// It can create a copy of itself (clone) and draw in its own way.
public class Circle implements Shape {
    private String color;
 
    // When you create a circle, you give it a color.
    public Circle(String color) {
        this.color = color;
    }
 
    // This creates a copy of the circle.
    @Override
    public Shape clone() {
        return new Circle(this.color);
    }
 
    // This is how a circle draws itself.
    @Override
    public void draw() {
        System.out.println("Drawing a " + color + " circle.");
    }
}

Este es un client que recibe el objeto que se considerara el prototipo, y devolverá un clon del mismo cada vez que se llame a createShape()

public class ShapeClient {
    private Shape shapePrototype;
 
    // When you create a client, you give it a prototype (a shape).
    public ShapeClient(Shape shapePrototype) {
        this.shapePrototype = shapePrototype;
    }
 
    // This method creates a new shape using the prototype.
    public Shape createShape() {
        return shapePrototype.clone();
    }
}

// Main class
public class PrototypeExample {
    public static void main(String[] args) {
        // Create a concrete prototype (a red circle).
        Shape circlePrototype = new Circle("red");
 
        // Create a client and give it the prototype.
        ShapeClient client = new ShapeClient(circlePrototype);
 
        // Use the prototype to create a new shape (a red circle).
        Shape redCircle = client.createShape();
 
        // Draw the newly created red circle.
        redCircle.draw();
    }
}

Si el objeto es mas complejo y tiene otros objetos en su interior, al modificar algun atributo de ese objeto, se modificarán para todas las instancias creadas a partir del prototype. Dado que se modifica la referencia de todos los objetos. Por ello si necesitamos clonar tambien los objetos internos, deberemos realizar una clonación profunda (deep cloning) con alguna librería o investigar como podemos hacerlo.

https://www.geeksforgeeks.org/prototype-design-pattern/

https://www.arquitecturajava.com/java-clone-un-concepto-importante/