El siguiente de los patrones que vamos a ver es el patrón Ptototype que pertenece, al igual que los anteriores, al grupo de patrones creacionales.

Este patrón tiene como objetivo la especificación de un tipo de objeto que será un prototipo para la creación de nuevos objetos copiando este, o mejor dicho, clonando este prototipo.

Una explicación más informal de estoy sería algo así como, construir una jerarquía de clases en las cuales, el primer objeto que se crea sea el prototipo, y a partir de este momento, no se van a crear más nuevos objetos, sino que se van a clonar estos a partir del primero. Por aproximarlo un poco a la programación, aunque luego veremos un ejemplo, nuestra aplicación hará un “new” del objeto prototipo y a partir de ahí, el esto de objetos se obtendrán por clonación.

Y esto, ¿para que sirve? Pues por un lado, viene a solventar problemas derivados de clases dependientes de factores externos que solo se conocerán en tiempo de ejecución y, por otro, nos permite evitar, en el caso de objetos muy complejos, los problemas en la creación de estos.

Se debería usar este patrón cuando el sistema debería ser independiente de cómo sus productos son creados, rellenados y presentados. Además, como ya he comentado, cuando la clase a instanciar se especifica en tiempo de ejecución o para evitar la creación de factorías con herencias de clases complejas o cuando las instancias de una clases difieren únicamente en un estado. En este último caso suele ser mejor, crear el prototipo y clonar dicho prototipo para obtener instancias de nuevos objetos.

Este patrón se compone de los siguientes elementos:

• Prototype: Declara una interfaz para clonarse.
• ConcretePrototype: Implementa la operación de clonación para si mismo.
• Client: Crea un nuevo objeto, pidiendo al prototype que se clone.

Aunque ya hemos adelantado una cuantas, las consecuencias de la utilización de este patrón son las siguiente:

1. Nos permitirá crear o borrar productos en tiempo de ejecución.
2. La especificación de objetos nuevos variando sus valores.
3. La especificación de objetos nuevos variando su estructura.
4. Reduce el número de subclases respecto al resultado si no utilizáramos este patrón o si utilizáramos otros como Factory Method para los casos que cubre Prototype.
5. Nos permite la configuración de una aplicación con clases dinámicas.

La única consideración importante que tenemos que tener, ya sabéis un “Must to Have” es que tenemos que implementar la operación de clonación en cada una de las clases que se van a generar a partir del prototipo. Solo con esto ya podemos realizar la implementación de nuestro patrón.

Peor bueno, ya para no aburriros más, vamos a pasar a un ejemplo de implementación, que al fin y al cabo es lo más divertido. Como siempre, el ejemplo va a ser en Java que, en este caso, nos aporta la interfaz Clonable en su API. Para el que no la conozca, le invito a echarle una ojeada, pero básicamente es un interfaz que nos ofrece Java para realizar una implementación rápida y fácil de este patrón. Esto nos da un ejemplo de lo extendido que está.

El caso más fácil a exponer, y que deliberadamente lo voy a exagerar un poco más para que veáis la utilidad del patrón, es la creación de objetos personas. En este caso concreto vamos a hacer una mini aplicación donde crearemos dos personas que serán hermanos para trabajar con ellos.

Prototype:

Será la clase ofrecida por el API de Java Clonable, con lo cual no la tendremos que implementar

ConcretePrototype:

public class Persona implements Comparable {
    /* Datos personales: Nombre, primer apellido, segundo apellido,
       nombrePadre, nombreMadre, teléfonoDomicilio, nacionalidad,
       calle, numero, ciudad, códigoPostal,… */
    /* Getters y Setters */
}

Client:

public class Main {
    public static void main(String[] args) {
        Persona juan = new Persona();
        /* llamada a setters (mínimo 11 para nuestro caso*/
        Persona maria = (Persona)juan.clone();
        /* Cambiar nombre */
        maria.setNombre(“Maria”);
        /* Trabajar con los objetos */
    }
}

Como se puede ver, la operación clone nos ha ahorrado un montón de setters, y esto hablado de un objeto muy simple. Ahora imaginad uno compuesto por objetos complejos o multitud de campos.

Bueno, hasta aquí hemos llegado por hoy. Nos vemos.