UNIVERSIDAD TECNOLÓGICA DE PANAMÁ

FACULTAD DE INGENIERÍA DE SISTEMAS COMPUTACIONALES

DEPARTAMENTO DE SISTEMAS DE INFORMACIÓN,

CONTROL Y EVALUACIÓN DE RECURSOS INFORMÁTICOS

LICENCIATURA EN INGENIERÍA DE SISTEMAS DE INFORMACIÓN

GERENCIAL

INGENIERÍA DE SOFTWARE II

PROYECTO DE INVESTIGACIÓN

“PROTOTYPE”

Dra. Gisela T. de Clunie Integrantes

Acosta, María | 8-1018-2180

Vargas, Victoria | 8-1023-489

II Semestre

2025
 Índice

Introducción ..............................................................................................................................3
1. Prototype ...........................................................................................................................4
2. Clasificación ......................................................................................................................4
3. Intención ............................................................................................................................4
4. Nombres Comunes ...........................................................................................................4
5. Motivación .........................................................................................................................4
6. Aplicabilidad ......................................................................................................................5
7. Estructura: .....................................................................................................................5
8. Participantes:.................................................................................................................5
9. Colaboraciones: ............................................................................................................6
10. Consecuencias: .........................................................................................................6
11. Implementación: ........................................................................................................7
12. Código de ejemplo: ...................................................................................................7
13. Usos conocidos: ........................................................................................................8
14. Patrones relacionados: .............................................................................................8
Conclusión ................................................................................................................................9
Bibliografía .............................................................................................................................. 10

2
 Introducción

En el campo de la ingeniería de software, los patrones de diseño representan soluciones

comprobadas a problemas recurrentes en la construcción de sistemas orientados a objetos. Se
originaron a mediados de la década de 1990 con la publicación del libro Design Patterns:
Elements of Reusable Object-Oriented Software de Erich Gamma, Richard Helm, Ralph Johnson
y John Vlissides, conocidos como la Banda de los Cuatro (GoF), el cual formalizó un lenguaje
común para describir problemas de diseño y sus respectivas soluciones (Gamma, Helm,
Johnson, & Vlissides, 1995).
Un patrón de diseño puede definirse como una plantilla o modelo conceptual que describe cómo
organizar clases y objetos para resolver una necesidad específica de manera eficiente,
reutilizable y mantenible. Estos patrones no son fragmentos de código predefinido, sino guías o
estructuras que pueden implementarse en distintos lenguajes de programación. Su objetivo
principal es mejorar la comunicación entre desarrolladores y fomentar la reutilización del
conocimiento de diseño (Freeman & Freeman, 2004).
En la programación orientada a objetos, los patrones de diseño se agrupan tradicionalmente en
tres categorías:
1. Creacionales, que se ocupan del proceso de instanciación de objetos.
2. Estructurales, que se centran en cómo se relacionan y componen las clases.
3. De comportamiento, que describen la manera en que los objetos interactúan entre sí
(Grand, 2002).
Los patrones creacionales son especialmente relevantes porque abordan uno de los desafíos
más frecuentes en el desarrollo de software: cómo crear objetos de manera flexible y
desacoplada, sin depender directamente de las clases concretas. En esta categoría se
encuentran patrones como Factory Method, Singleton, Builder, Abstract Factory y Prototype
(Shvets, 2020). Cada uno aborda un enfoque distinto para controlar la creación de instancias,
mejorar la extensibilidad del sistema y reducir la complejidad del código.
El patrón Prototype se destaca dentro de este grupo porque propone una solución elegante para
los casos en que crear un objeto desde cero resulta costoso o ineficiente. En lugar de generar
una nueva instancia mediante un constructor, este patrón permite duplicar o clonar un objeto ya
existente, conservando su estado y estructura, pero sin establecer dependencias con su clase
concreta (Shvets, 2020).
La comprensión del patrón Prototype requiere, por tanto, un entendimiento previo de algunos
principios fundamentales de la programación orientada a objetos, como encapsulamiento,
reutilización y bajo acoplamiento. Estos principios buscan que cada componente de un sistema
sea autónomo y modificable sin afectar al resto, favoreciendo así la mantenibilidad y la
escalabilidad del software (Gamma et al., 1995).
Es por esto, que estudiar el patrón Prototype permite explorar cómo los principios de diseño
orientado a objetos pueden aplicarse para optimizar la creación de objetos, reducir el uso de
recursos y mejorar la flexibilidad del sistema. Este documento presenta una investigación
detallada del patrón, su clasificación, motivación, estructura interna, participantes, consecuencias
en el diseño e implementación práctica, con el fin de ofrecer una visión completa de su función
dentro de los patrones creacionales de la ingeniería de software moderna.

3
 1. Prototype
De acuerdo con Shvets (2020), el nombre oficial del patrón es Prototype Pattern, traducido al
español como Prototipo. Este término, ampliamente utilizado en ingeniería y diseño, hace
referencia a un modelo base o ejemplar inicial a partir del cual pueden derivarse copias o
adaptaciones. En el contexto del desarrollo de software, el patrón Prototype establece un
mecanismo que permite crear nuevos objetos duplicando un modelo existente, evitando la
necesidad de construirlos desde cero. Esta estrategia ofrece una alternativa más eficiente y
flexible para la generación de instancias cuando se requiere mantener las mismas
configuraciones o estados de un objeto base.

2. Clasificación
Dentro de la clasificación propuesta por la literatura sobre patrones de diseño, Shvets (2020)
ubica Prototype en la familia de los patrones creacionales. Estos se centran en los procesos de
instanciación de objetos, buscando independencia entre el código que los crea y el código que
los utiliza. En este sentido, el patrón Prototype define el tipo de objetos a generar mediante una
instancia prototípica, la cual puede ser copiada cuantas veces sea necesario. Tal enfoque
simplifica el proceso de creación, reduce la dependencia de los constructores tradicionales y
promueve un diseño más flexible y mantenible.

3. Intención
Prototype busca resolver problemas como cuando necesitamos duplicar un objeto, copiarlo
“desde fuera” exige crear una instancia de su misma clase y replicar todos sus campos, pero esto
introduce varias dificultades, ya que algunos atributos pueden ser privados e inaccesibles, lo que
obliga a conocer la clase concreta, aumentando el acoplamiento, y a menudo sólo disponemos
de la interfaz del objeto, no de su tipo real, lo que impide instanciarlo directamente. El patrón
Prototype resuelve estas problemáticas delegando la clonación en el propio objeto ya que define
una interfaz común que cada clase implementa para crear su copia interna, trasladando de forma
controlada todos los campos, incluidos los privados, y permitiendo duplicar instancias sin
depender de su clase concreta, reduciendo acoplamiento y errores en la copia. (Shvets, 2020)

4. Nombres Comunes
El patrón Prototype también se conoce como Clone, clonar prototipo o patrón prototipo; en este
documento nos referiremos a él simplemente como Prototype. T

n conocido como

5. Motivación
Este patrón es altamente útil en escenarios en donde no conviene separar (o no se puede separar
con precisión) la lógica que decide qué tipos de objetos usará la aplicación, de la lógica que esos
objetos ejecutarán después. A menudo la elección del tipo depende de configuraciones o
parámetros en tiempo de ejecución, por lo que se requiere crear nuevas instancias a partir de
modelos existentes. Dichos modelos, o prototipos, se clonan para generar objetos idénticos,
incluido su estado interno. Esto es especialmente conveniente en escenarios como el planteado
ya que se tiene la libertad para producir en tiempo de ejecución copias de objetos concretos
previamente definidos, o cuando una clase solo maneja un conjunto reducido de combinaciones
de estado posibles. (Wikipedia, 2025)

4
6. Aplicabilidad
Usos comunes y criterios de aplicabilidad (Guzmán, 2024):
1. Costos elevados de creación: Cuando instanciar un objeto requiere inicialización
compleja o uso intensivo de recursos.
2. Objetos configurables: En sistemas que necesitan muchas versiones similares con
ligeras variaciones.
3. Reducción de dependencias: Cuando se desea evitar un fuerte acoplamiento con las
clases concretas.
4. Procesamiento de documentos: Para crear versiones nuevas a partir de una plantilla
base.
5. Diseño gráfico: Al generar elementos visuales semejantes (formas, íconos, figuras).
6. Prototipos de productos: En simulaciones o pruebas que requieren duplicar
configuraciones existentes.

7. Estructura:

Ilustración 1. Estructura representativa del patron de diseño prototype

En el diagrama de clases UML anterior, la clase Client se refiere a la interfaz Prototype para
clonar un Product. La clase Product1 implementa la interfaz Prototype creando una copia de sí
misma. El diagrama de secuencia UML muestra las interacciones en tiempo de ejecución: El
objeto Client llama a clone() en un objeto prototype:Product1, que crea y devuelve una copia de
sí mismo (un product: Producto1 objeto). (AcademiaLab, s.f.)

8. Participantes:
En el patrón Prototype intervienen tres participantes principales:
1. Prototype (Prototipo):
 Define la interfaz o estructura general que todos los objetos clonables deben tener.
 Contiene el método clone(), encargado de producir la copia.

5
 2. Concrete Prototype (Prototipo Concreto):
 Es la clase que implementa la interfaz Prototype y define cómo se realiza la clonación
de sus propios datos o estructuras internas.
3. Client (Cliente):
 Representa la parte del programa que utiliza los objetos. En lugar de crear nuevos
elementos desde cero, solicita copias al prototipo mediante el método clone().
 De esta forma, el cliente obtiene nuevas instancias completamente configuradas, sin
necesidad de conocer los detalles de su construcción.
En términos simples, el cliente no necesita conocer los detalles internos del objeto ni cómo fue
construido. Solo debe saber que puede pedir una copia funcional y personalizada.

9. Colaboraciones:
El funcionamiento puede explicarse paso a paso de la siguiente manera:
a. El cliente identifica un objeto existente que servirá como modelo o prototipo.
b. En lugar de crear un nuevo objeto desde cero, el cliente llama al método clone() del
prototipo.
c. El prototipo crea una nueva instancia, idéntica a sí mismo, y se la entrega al cliente.
d. El cliente, si lo desea, modifica algunos valores de la copia (por ejemplo, cambiar un
nombre o un parámetro), sin alterar el prototipo original.
Este mecanismo puede compararse con el llenado de un formulario digital: en lugar de escribir
toda la información desde cero, el usuario duplica una versión ya completada y solo ajusta los
datos necesarios. De igual manera, el patrón Prototype permite obtener múltiples versiones
personalizadas a partir de un modelo común (Gamma et al., 1995).

10. Consecuencias:
La incorporación del patrón Prototype en el diseño de software produce efectos importantes en
la estructura interna y en la dinámica del sistema.
En primer lugar, este patrón permite abstraer la creación de objetos y ocultar las clases concretas
al cliente, es decir, al componente que solicita las instancias. De este modo, el cliente no necesita
conocer las clases exactas de los objetos que manipula; basta con que sepa que estos pueden
clonarse a través de la interfaz definida por el prototipo (Gamma, Helm, Johnson, & Vlissides,
1995). Esta característica mejora la encapsulación y el bajo acoplamiento, cualidades esenciales
en los sistemas orientados a objetos.
Asimismo, el patrón Prototype proporciona una configuración dinámica de la aplicación, ya que
posibilita la creación, adición o eliminación de objetos en tiempo de ejecución mediante la
operación de clonación. Esta capacidad otorga gran flexibilidad a sistemas que deben adaptarse
a cambios o generar nuevas combinaciones de objetos sin alterar su estructura base (Freeman
& Freeman, 2004).
Otra consecuencia relevante es la reducción de la cantidad de subclases. En lugar de definir
múltiples clases derivadas para representar variaciones mínimas de un mismo objeto, el patrón
permite instanciar copias de un modelo base y modificarlas según las necesidades del programa.
Esto simplifica la jerarquía de clases, facilita el mantenimiento del código y mejora su legibilidad
(Shvets, 2020).

6
Desde una perspectiva funcional, el patrón también permite definir nuevos objetos de forma
incremental. El desarrollador puede generar una instancia inicial con valores predeterminados y,
posteriormente, aplicar cambios específicos sobre la copia, tanto en sus atributos como en su
estructura. (Grand, 2002).
Sin embargo, no todas las consecuencias son beneficiosas. Implementar correctamente la
jerarquía de prototipos puede resultar complejo, especialmente cuando los objetos poseen
referencias circulares o estructuras internas compuestas. Además, si las operaciones de
clonación se ejecutan con frecuencia en objetos grandes, el costo computacional puede volverse
considerable, lo que impacta el rendimiento del sistema (Gamma et al., 1995).

11. Implementación:
Para implementar este patrón se debe incluir un método de clonación en la clase base que actúe
como prototipo. En lenguajes modernos, existen herramientas integradas para facilitar esta tarea.
Por ejemplo, en Python puede utilizarse la librería copy que permite realizar copias profundas de
los objetos, garantizando que todas sus estructuras internas se dupliquen correctamente.

12. Código de ejemplo:

Ilustración 2. Código implementando Prototype. Elaboración propia

En este ejemplo, la clase Document actúa como prototipo. A partir de un modelo base, se
crean copias personalizadas, sin necesidad de reescribir el contenido ni de construir un nuevo
documento desde cero.

7
 13. Usos conocidos:
Aunque su aplicación es muy técnica, el principio del patrón Prototype se observa en múltiples
herramientas de uso cotidiano.
Por ejemplo:
 Cuando un usuario crea un nuevo documento en un procesador de texto a partir de una
plantilla existente.
 Al duplicar una diapositiva en una presentación para conservar su formato.
 En sistemas administrativos, al generar facturas o reportes basados en modelos
predefinidos.
En todos estos casos, el software no crea los elementos desde cero: utiliza un modelo (el
prototipo) y produce una copia editable, aplicando el mismo principio conceptual.

14. Patrones relacionados:

El patrón Prototype guarda relación con otros patrones creacionales:
1. Factory Method: crea objetos mediante una “fábrica”, pero Prototype los genera mediante
clonación.
2. Builder: construye objetos paso a paso; Prototype, en cambio, los replica de inmediato.
3. Singleton: restringe la existencia a una única instancia, mientras que Prototype promueve
múltiples copias a partir de un modelo común (Gamma et al., 1995).

8
 Conclusión
El patrón Prototype constituye una de las soluciones más representativas dentro de los patrones
creacionales de la ingeniería de software, ya que aborda un aspecto esencial del desarrollo
orientado a objetos: la creación eficiente y flexible de instancias. A diferencia de los métodos de
instanciación tradicionales, que requieren conocer la clase concreta del objeto, este patrón
propone un mecanismo basado en la clonación controlada de un modelo preexistente, conocido
como prototipo. Este enfoque permite duplicar objetos complejos sin depender de su estructura
interna, lo que reduce el acoplamiento y mejora la capacidad de mantenimiento del sistema
(Gamma, Helm, Johnson, & Vlissides, 1995).
Desde el punto de vista del diseño, Prototype favorece la reutilización de estructuras ya probadas
y proporciona una alternativa eficaz cuando la creación de objetos nuevos implica altos costos
computacionales o configuraciones extensas. Su aplicación posibilita la definición de sistemas
más adaptables, capaces de modificar o extender su comportamiento en tiempo de ejecución sin
alterar la arquitectura general. En este sentido, el patrón aporta un equilibrio entre eficiencia,
encapsulación y flexibilidad, cualidades que fortalecen la calidad y la escalabilidad del software
(Freeman & Freeman, 2004).
Sin embargo, la adopción de este patrón también exige una comprensión del ciclo de vida de los
objetos y de las implicaciones de la clonación en memoria. La correcta implementación del
método clone() o de operaciones equivalentes depende del contexto de cada lenguaje de
programación y puede requerir el uso de copias profundas para garantizar la integridad de los
datos (Grand, 2002). Este aspecto técnico subraya que el patrón Prototype no debe aplicarse de
manera indiscriminada, sino como una estrategia de diseño consciente y justificada.
En el ámbito académico, estudiar el patrón Prototype permite a los estudiantes comprender de
forma tangible cómo los principios del diseño orientado a objetos, como la abstracción, la
reutilización y el bajo acoplamiento, se traducen en soluciones prácticas dentro de la ingeniería
de software. Además, demuestra cómo los patrones de diseño no son únicamente herramientas
técnicas, sino también modelos conceptuales que fomentan el pensamiento crítico, la
organización estructurada del código y la resolución sistemática de problemas.
Como cierre, el patrón Prototype representa una herramienta de gran valor tanto para el
aprendizaje como para la práctica profesional. Su comprensión fortalece la capacidad de los
futuros ingenieros para diseñar sistemas más coherentes, sostenibles y adaptables a los
cambios, reafirmando la idea central de los patrones de diseño: no reinventar soluciones, sino
reutilizar el conocimiento estructurado que la disciplina ya ha validado.

9
 Bibliografía

Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1995). Design Patterns: Elements of
Reusable Object-Oriented Software. Addison-Wesley. Revisado el 15 de octubre del 2025
Freeman, E., & Freeman, E. (2004). Head First Design Patterns. O’Reilly Media. Revisado el 15
de octubre del 2025
Grand, M. (2002). Patterns in Java (Vol. 1): A Catalog of Reusable Design Patterns Illustrated in
Java. Wiley. Revisado el 15 de octubre del 2025
Shvets, A. (2020). Sumérgete en los patrones de diseño. [Link] Press. Revisado el
19 de octubre del 2025
AcademiaLab. (n.d.). Patrón de prototipo. Retrieved from AcademiaLab (Enciclopedia):
[Link] Revisado el 18 de octubre del 2025
Guzmán, E. (2024, noviembre 18). Prototype – Serie de patrones de diseño. Retrieved from
Oracle Middleware and Development Specialist.: [Link]
patrones-de-diseno-en-java/ Revisado el 119 de octubre del 2025
[Link]. (n.d.). Prototype. Retrieved from Refactoring Guru:
[Link] Revisado el 19 de octubre del 2025
Wikipedia. (2025, marzo 28). Prototipo (patrón de diseño). Retrieved from Wikipedia, la
enciclopedia libre: [Link]
Revisado el 18 de octubre del 2025

10