Patrón prototipo y sus ejemplos.

---

Prefacio

El patrón prototipo es un patrón de creación entre los 23 patrones de diseño:
un patrón de creación es un tipo de patrón de diseño que se utiliza para crear objetos y mecanismos. Proporcionan una forma flexible de crear instancias de objetos mientras ocultan los detalles de la creación de objetos, lo que hace que el código sea más fácil de mantener, extensible y reutilizable.

---

1. Modo prototipo

El uso de un patrón prototipo es un patrón de diseño eficaz cuando necesitamos crear varios objetos similares. El patrón prototipo crea nuevos objetos clonando objetos existentes, evitando procesos repetidos de creación de objetos y mejorando el rendimiento y la mantenibilidad del código. En el desarrollo de software, a menudo nos encontramos con situaciones en las que necesitamos crear una gran cantidad de objetos similares. La forma tradicional de crear objetos es crear instancias de nuevos objetos llamando a constructores, lo que puede causar problemas de rendimiento al crear objetos complejos. Además, la lista de parámetros de un constructor puede volverse larga, lo que dificulta el mantenimiento y la comprensión del código. El patrón de prototipo proporciona una solución mediante la creación de nuevos objetos basados ​​en objetos existentes sin pasar por constructores ni parámetros de inicialización.

Cómo funciona:
un objeto sirve como prototipo y se crean nuevos objetos copiándolos (clonándolos). En Java, puede implementar operaciones de clonación de objetos implementando la interfaz Cloneable y anulando el método clone().

2. Copia superficial y copia profunda

1. Copia superficial

**Copia superficial: **La copia superficial crea un objeto clonado y copia los valores de campo del objeto original. Si el campo es un tipo de valor, su valor se copia; si el campo es un tipo de referencia, la referencia se copia para que los objetos original y clonado compartan el mismo objeto de referencia. Existe una cierta relación entre el objeto clonado de copia superficial y el objeto original. Ambos comparten la misma dirección y no se abre ninguna nueva dirección de memoria.

2. Copia profunda

Copia profunda: la copia profunda
crea un objeto clonado y copia los valores de campo del objeto original, incluido el objeto de referencia. La copia profunda copiará recursivamente el objeto de referencia para que el objeto original y el objeto clonado sean completamente independientes y no se afecten entre sí. Es más como crear un nuevo objeto y asignarle las propiedades del objeto original al nuevo objeto: el nuevo objeto tiene su propia dirección de memoria y es independiente del objeto original.

3. Ejemplos de código

1. Clase de dirección
Es un atributo de la clase Persona.

public class Address {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

2. Objeto experimental de clase Persona
, implementa Cloneable y anula el método de clonación.

public class Person implements Cloneable{
    private String name;
    private Address address;

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

3. Clase de prueba
En la siguiente clase de prueba, los objetos clonados se crean utilizando dos métodos diferentes: copia superficial y copia profunda, y luego se comparan con el objeto original para comparar las diferencias entre los dos métodos.
Comparación entre el objeto clon superficial y el objeto original: verdadero, las dos direcciones son las mismas y el contenido es el mismo
Comparación entre el objeto clon superficial modificado y el objeto original: verdadero, la misma dirección y cambios al mismo tiempo tiempo después de la modificación.
Comparación entre el objeto de clonación profunda y el objeto original: falso, los valores son los mismos pero Las direcciones son diferentes, por lo que == se juzga incorrectamente.
Compare el objeto de clonación profunda modificado con el objeto original: falso Las direcciones son diferentes, por lo que la modificación no es válida para el objeto original.
Nota: == compara valores y direcciones, igual solo compara sus valores.

public class PrototypeExample {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("New York");
        Person person1 = new Person("John", address);

        // 浅拷贝
        Person person2 = (Person) person1.clone();
        System.out.println("浅拷贝地址相同：" + (person1.getAddress() == person2.getAddress()));

        // 修改person2的地址
        person2.getAddress().setCity("Los Angeles");
        System.out.println("浅拷贝地址同时改变：" + (person1.getAddress().getCity().equals(person2.getAddress().getCity())));

        // 深拷贝
        Person person3 = new Person(person1.getName(), new Address(person1.getAddress().getCity()));
        System.out.println("深拷贝地址不同：" + (person1.getAddress() == person3.getAddress()));

        // 修改person3的地址
        person3.getAddress().setCity("San Francisco");
        System.out.println("深拷贝地址独立：" + (person1.getAddress().getCity().equals(person3.getAddress().getCity())));
    }
}

Resumir

El patrón prototipo es un patrón de creación que crea nuevos objetos copiando objetos existentes. Proporciona una forma flexible y eficiente de crear objetos, lo que puede mejorar el rendimiento y la capacidad de mantenimiento del código en escenarios que requieren una gran cantidad de objetos similares. Al utilizar copias superficiales o profundas, el patrón prototipo puede clonar objetos de manera flexible para que los nuevos objetos sean independientes de los objetos originales.