PATRÓN PROTOTYPE

Algoritmo y Estructura de datos

 UNIVERSIDAD TECNOLOGICA
DEL PERÚ

ALGORITMO Y ESTRUCTURA DE
DATOS

TEMA:

PATRÓN PROTOTYPE

Integrantes:
 Alcalá Valdiavia, Job
 Lazo Janampa, Luis
 Melendez Ramirez de Castilla, Jorge
 Pajuelo Padin, Aldo
 Segura Avalos, Roy

1
 Índice

Contenido
Introducción ................................................................................................................................3
Patrón Prototype ........................................................................................................................4
Concepto Patrón Prototype: .................................................................................................4
Uso de patrón prototype .......................................................................................................4
Solución y Estructura: ...........................................................................................................4
Solución: .............................................................................................................................4
La estructura es la siguiente: ...........................................................................................5
Positivo y negativo: ...........................................................................................................5
Ejemplo .......................................................................................................................................6
Aplicación ...................................................................................................................................9
Aplicación 01 ..........................................................................................................................9
Clase TV: ............................................................................................................................9
Clase LCD: .......................................................................................................................11
Clase Plasma: ..................................................................................................................12
Clase TVPrototype: .........................................................................................................12
Programa Principal: -> ....................................................................................................13
Aplicación funcionando: ..................................................................................................14
Consecuencias ....................................................................................................................14
Conclusión. ...............................................................................................................................15
Bibliografía................................................................................................................................16

2
 Introducción

Como analistas y programadores vamos desarrollando a diario nuestras habilidades

para resolver problemas usuales que se presentan en el desarrollo del software. Por
cada problema que se nos presenta pensamos distintas formas de resolverlo,
incluyendo soluciones exitosas que ya hemos usado anteriormente en problemas
similares. Es así como a mayor experiencia que tengamos, nuestro abanico de
posibilidades para resolver un problema crece, pero al final siempre habrá una sola
solución que mejor se adapte a nuestra aplicación. Si documentamos esta solución,
podemos reutilizarla y compartir esa información que hemos aprendido para resolver de
la mejor manera un problema específico.

3
 Patrón Prototype

Concepto Patrón Prototype:

El patrón de diseño Prototype sirve para crear clonaciones de objetos (instancias de
clases) a fin de no acarrear todo lo que lleva la creación del mismo desde
cero, parámetros, métodos a ejecutar, etc. Hay que tener en cuenta que clonar un
objeto es mucho más rápido que crearlo.

Una explicación más informal de esto 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.

Uso de patrón prototype

 Para evitar las subclases de un objeto creador como hace el patrón Abstract
Factory.
 Para evitar el costo inherente a la creación de un objeto nuevo mediante el
operador new cuando esto demasiado costoso para la aplicación.


Solución y Estructura:
Solución:

La solución consistirá en definir una interfaz que expone el método necesario para
realizar la clonación del objeto. Las clases que pueden ser clonadas implementarán esta
interfaz, mientras que las clases que deseen clonar deberán utilizar el método definido
en la interfaz.

Además, existen 2 tipos de clonación: la clonación profunda y la clonación superficial.

En la clonación superficial modificar las referencias a terceros objetos hace que los
originales cambien, ya que los terceros objetos son en realidad punteros. En la clonación
profunda se clonan los terceros objetos dando lugar a nuevas referencias
independientes.

4
 La estructura es la siguiente:

Dónde:

Prototype: Interfaz que define la operación de clonado. Será implementada por todos
los objetos que puedan ser clonados. En ocasiones es implementado como una clase
abstracta.

Client: Crea nuevos objetos mediante la clonación de los mismos.

ConcretePrototype1: Clase que puede ser instanciada mediante la clonación de un

prototipo. Implementa la interfaz Prototype.

ConcretePrototype2: Otra clase con las mismas características que

ConcretePrototype1.

Positivo y negativo:

 POSITIVAS:
o Clonar un objeto es mucho más rápido que crearlo.
o Un programa puede añadir y borrar dinámicamente objetos prototipo en
tiempo de ejecución.
o El cliente no debe conocer los detalles de cómo construir los objetos
prototipo.

 NEGATIVAS:
o En objetos muy complejos, implementar la interfaz Prototype puede ser
muy complicada.

5
Ejemplo:
Nuestro ejemplo será muy sencillo: prototipos de TVs. Para ello crearemos la clase TV
y dos subclases: LCD y Plasma. ¿Ya debería ir cambiando Plasma por Led no?

6
Y, por otro lado, tenemos gestor de prototipos: TvPrototype.

7
La invocación desde un Cliente sería:

8
 Aplicación

Aplicación 01
Vamos a crear una clase de prototipos de TVs. Para ello crearemos la clase TV y dos
subclases: LCD y Plasma. Según este esquema:

Clase TV:
Esta clase tiene el método Clone() que se encarga de hacer una copia de si misma y de
devolverla.
->

9
10
Clase LCD:
El método clone() lo redefinimos según las propiedades de los tv del tipo LCD ->

11
Clase Plasma:
El método clone() lo redefinimos segun las propiedades de los tv del tipo Plasma ->

Clase TVPrototype:
En esta clase, predefinimos los distintos tipos que va a tener el cliente disponible. ->

12
Programa Principal:
->

13
Aplicación funcionando:

Consecuencias

 Un programa puede dinámicamente añadir y borrar objetos prototipo en

tiempo de ejecución. Esta es una ventaja que no ofrece ninguno de los
otros patrones de creación.
 Esconde los nombres de los productos específicos al cliente.
 Se pueden especificar nuevos objetos prototipo variando los existentes.
 La clase Cliente es independiente de las clases exactas de los objetos
prototipo que utiliza. y, además, no necesita conocer los detalles de cómo
construir los objetos prototipo.
 Clonar un objeto es más rápido que crearlo.
 Se desacopla la creación de las clases y se evita repetir la instanciación
de objetos con parámetros repetitivos.

14
 Conclusión

Debido a que el patrón Prototye hace uso del método clone(), es necesaria una mínima
explicación de su funcionamiento: todas las clases en Java heredan un método de la
clase Object llamado clone. Un método clone de un objeto retorna una copia de ese
objeto. Esto solamente se hace para instancias de clases que dan permiso para ser
clonadas. Una clase da permiso para que su instancia sea clonada si, y solo si, ella
implementa la interface Cloneable.

Por otro lado, es importante destacar que si va a variar el número de prototipos se puede
utilizar un "administrador de prototipos". Otra opción muy utilizada es un Map como se
ve en el ejemplo.

15
 Bibliografía

1. Maximiliano Juarez. (30 de mayo de 2011) Mi granito de java Recuperado de:

http://migranitodejava.blogspot.pe/2011/05/prototype.html?m=1

2. El lado oscuro de java. (28 de octubre de 2014). El lado oscuro de java.

Recuperado de: http://java-white-box.blogspot.pe/2014/10/patrones-de-diseno-
patron-prototype-que.html?m=1

3. Jorge. (23 de febrero de 2010). Tratando de entenderlo. Recuperado de:

http://tratandodeentenderlo.blogspot.pe/2010/02/patrones-de-diseno-
prototype.html?m=1

4. A. Matías Quezada. (18 enero, 201219 marzo, 2014). Conceptos Básicos

Javascript: Herencia por prototipos. Recuperado de:
http://blog.amatiasq.com/2012/01/javascript-conceptos-basicos-herencia-por-
prototipos/

5. Julio Sanchez. (2 de enero de 2014). Gambas Mis Programas y el

Softwarelibre. Recuperado de: http://jsbsan.blogspot.pe/2014/01/patron-
prototype-ejemplo-tipos-de.html?m=1

6. Mundo Informático. Recuperado de:

https://infow.wordpress.com/2013/03/30/gof-patrones-de-diseno-vi-prototype/

7. Patrones de Diseño (V): Patrones de Creación – Prototipo. Recuperado de:

http://programacion.net/articulo/patrones_de_diseno_v_patrones_de_creacion_
prototipo_1005

16