Prototype (patrón de diseño)

De Wikipedia, la enciclopedia libre

Tabla de contenidos 1 Propósito 2 Motivación 3 Solución 4 Implementación

[editar] Propósito

El patrón de diseño Prototype (Prototipo), tiene como finalidad crear nuevos objetos duplicándolos, clonando una instancia creada previamente.

[editar] Motivación

Este patrón es motivo donde en ciertos escenarios es preciso abstraer la lógica que decide que tipos de objetos utilizará una aplicación, de la lógica que luego usarán esos objetos en su ejecución. Los motivos de esta separación pueden ser variados, por ejemplo, puede ser que la aplicación deba basarse en alguna configuración o parámetro en tiempo de ejecución para decidir el tipo de objetos que se debe crear.

[editar] Solución

Este patrón propone la creación de distintas variantes del objeto que nuestra aplicación necesite, en el momento y contexto adecuado. Toda la lógica necesaria para la decisión sobre el tipo de objetos que usará la aplicación en su ejecución debería localizarse aquí. Luego, el código que utiliza estos objetos solicitará una copia del objeto que necesite. En este contexto, una copia significa otra instancia del objeto. El único requisito que debe cumplir este objeto es suministrar la prestación de clonarse. Cada uno de los objetos prototipo debe implementar el método Clone().

[editar] Implementación

Esta es una solución en el lenguaje C.Sharp de DotNet:

using System;
// "Prototype"
abstract class Prototype {

        private string _id;

        public Prototype( string id ) {
                _id = id;
        }

        public string ID {
                get{ return _id; }
        }

        abstract public Prototype Clone();
}

class ClsConcreta1 : Prototype {
        public ClsConcreta1 ( string id ) : base ( id ) {}

        override public Prototype Clone() {
                // Shallow copy
                return (Prototype)this.MemberwiseClone();
        }
}

class PrototypeClient {
        public static void Main(string[] argv) {
                // Instancio ClsConcreta1 y luego la clono
                ClsConcreta1 p1 = new ClsConcreta1 ("Clone-I");
                ClsConcreta1 c1 = (ClsConcreta1) p1.Clone();
                Console.WriteLine( "Clonación: {0}", c1.ID );         
        }
}

Esta es otra implementación distinta en el lenguaje Java:

// Los productos deben implementar esta interface
public interface Producto extends Cloneable {
    Object clone();
    // Aqui van todas las operaciones comunes a los productos que genera la factoria
}

// Un ejemplo basico de producto
public class UnProducto implements Producto {
    private int atributo;

    UnProducto(int atributo) {
        this.atributo = atributo;
    }

    public Object clone() {
        return new UnProducto(this.atributo);
    }

    public String toString() {
        return ((Integer)atributo).toString();
    }
}

// La clase encargada de generar objetos a partir de los prototipos
public class FactoriaPrototipo {
    private HashMap mapaObjetos;
    private String nombrePorDefecto;

    public FactoriaPrototipo() {
        mapaObjetos = new HashMap();
        // Se incluyen al mapa todos los productos prototipo
        mapaObjetos.put("producto 1", new UnProducto(1));
    }

    public Object create() {
        return create(nombrePorDefecto);
    }

    public Object create(String nombre) {
        nombrePorDefecto = nombre;
        UnProducto objeto = (UnProducto)mapaObjetos.get(nombre);
        return objeto != null ? objeto.clone() : null;
    }
}

public class PruebaFactoria {
    static public void main(String[] args) {
        FactoriaPrototipo factoria = new FactoriaPrototipo();
        Producto producto = (Producto) factoria.create("producto 1");
        System.out.println ("Este es el objeto creado: " + producto);
    }
}

Patrones de Diseño
Creacionales: Abstract Factory | Builder | Factory Method | Prototype | Singleton | Secreton
Estructurales: Adapter | Bridge | Composite | Decorator | Facade | Flyweight | Proxy
De Comportamiento: Chain of Responsibility | Command | Interpreter | Iterator | Mediator | Memento | Observer | State | Strategy | Template Method | Visitor