c





À
À 

El diseño es un modelo del sistema, realizado con una serie de principios y técnicas, que
permite describir el sistema con el suficiente detalle como para ser implementado. Pero
los principios y reglas no son suficientes, en el contexto de diseño podemos observar
que los buenos ingenieros tienen esquemas y estructuras de solución que usan
numerosas veces en función del contexto del problema. Este es el sentido cabal de la
expresión "tener un mente bien amueblada", y no el significado de tener una notable
inteligencia. Estos esquemas y estructuras son conceptos reusables y nos permiten no
reinventar la rueda. Un buen ingeniero reutiliza un esquema de solución ante problemas
similares.

?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?

      
1
 c




c

 À

?
?
u




 



Patrones de diseño o más comúnmente conocidos como "Design Patterns son soluciones
simples y elegantes a problemas específicos y comunes del diseño orientado a objetos.
Son soluciones basadas en la experiencia y que se ha demostrado que funcionan.

Los patrones de diseño son la base para la búsqueda de soluciones a problemas comunes
en el desarrollo de software y otros ámbitos referentes al diseño de interacción o
interfaces.

Un patrón de diseño es una solución a un problema de diseño. Para que una solución sea
considerada un patrón debe poseer ciertas características. Una de ellas es que debe haber
comprobado su efectividad resolviendo problemas similares en ocasiones anteriores.

Otra es que debe ser reusable, lo que significa que es aplicable a diferentes problemas
de diseño en distintas circunstancias.

Es evidente que a lo largo de multitud de diseños de aplicaciones hay problemas que se

repiten o que son análogos, es decir, que responden a un cierto patrón. Sería deseable
tener una colección de dichos patrones con las soluciones más óptimas para cada caso.

Los patrones de diseño no son fáciles de entender, pero una vez entendido su
funcionamiento, los diseños serán mucho más flexibles, modulares y reutilizables. Han
revolucionado el diseño orientado a objetos y todo buen arquitecto de software debería
conocerlos.





 


En 1979 el arquitecto Christopher Alexander aportó al mundo de la arquitectura el libro

The Timeless Way of Building; en él proponía el aprendizaje y uso de una serie de
patrones para la construcción de edificios de una mayor calidad.
En palabras de este autor, "Cada patrón describe un problema que ocurre infinidad de
veces en nuestro entorno, así como la solución al mismo, de tal modo que podemos
utilizar esta solución un millón de veces más adelante sin tener que volver a pensarla
otra vez."
Los patrones que Christopher Alexander y sus colegas definieron, publicados en un
volumen denominado A Pattern Language, son un intento de formalizar y plasmar de
una forma práctica generaciones de conocimiento arquitectónico. Los patrones no son
principios abstractos que requieran su redescubrimiento para obtener una aplicación
satisfactoria, ni son específicos a una situación particular o cultural; son algo
intermedio. Un patrón define una posible solución correcta para un problema de diseño
dentro de un contexto dado, describiendo las cualidades invariantes de todas las
soluciones.

      
2
 c




Más tarde, en 1987, Ward Cunningham y Kent Beck usaron varias ideas de Alexander
para desarrollar cinco patrones de interacción hombre-ordenador (HCI) y publicaron un
artículo en OOPSLA-87 titulado Using Pattern Languages for OO Programs.
No obstante, no fue hasta principios de la década de 1990 cuando los patrones de diseño
tuvieron un gran éxito en el mundo de la informática a partir de la publicación del libro
Design Patterns escrito por el grupo Gang of Four (GoF) compuesto por Erich Gamma,
Richard Helm, Ralph Johnson y John Vlisides, en el que se recogían 23 patrones de
diseño comunes.

â




 

Los patrones de diseño pretenden:

ß? Proporcionar catálogos de elementos reusables en el diseño de sistemas

software.
ß? Evitar la reiteración en la búsqueda de soluciones a problemas ya conocidos y
solucionados anteriormente.
ß? Formalizar un vocabulario común entre diseñadores.
ß? Estandarizar el modo en que se realiza el diseño.
ß? Facilitar el aprendizaje de las nuevas generaciones de diseñadores condensando
conocimiento ya existente.

Asimismo, no pretenden:

ß? Imponer ciertas alternativas de diseño frente a otras.

ß? Eliminar la creatividad inherente al proceso de diseño.
ß? No es obligatorio utilizar los patrones, solo es aconsejable en el caso de tener el
mismo problema o similar que soluciona el patrón, siempre teniendo en cuenta
que en un caso particular puede no ser aplicable. "Abusar o forzar el uso de los
patrones puede ser un error".







 

La clave para la reutilización es anticiparse a los nuevos requisitos y cambios, de modo

que los sistemas evolucionen de forma adecuada. Cada patrón permite que algunos
aspectos de la estructura del sistema puedan cambiar independientemente de otros
aspectos. Facilitan la reusabilidad, extensibilidad y mantenimiento.

Un patrón es un esquema o microarquitectura que supone una solución a problemas

(dominios de aplicación) semejantes (aunque los dominios de problema pueden ser muy
diferentes e ir desde una aplicación CAD a un cuadro de mando empresarial). Interesa
constatar una vez más la vieja distinción entre dominio del problema (donde aparecen
las clases propias del dominio, como cuenta, empleado, coche o beneficiario) y el
dominio de la solución o aplicación (donde además aparecen clases como ventana,
menú, contenedor o listener). Los patrones son patrones del dominio de la solución.

      
3
 c




También conviene distinguir entre un patrón y una arquitectura global del sistema. Por
decirlo en breve, es la misma distancia que hay entre el diseño de un componente (o
módulo) y el análisis del sistema. Es la diferencia que hay entre el aspecto micro y el
macro, por ello, en ocasiones se denomina a los patrones como "microarquitecturas".

En resumen, un patrón es el denominador común, una estructura común que tienen

aplicaciones semejantes. Esto también ocurre en otros órdenes de la vida. Por ejemplo,
en nuestra vida cotidiana aplicamos a menudo el esquema saludo-presentación-mensaje-
despedida en ocasiones diversas, que van desde un intento de ligar hasta dar una
conferencia (si todavía no cree que existan patrones o que no son útiles intente ligar con
el esquema despedida-mensaje-presentación-saludo, a ver que ocurre).

$

!"



 

Según la escala o nivel de abstracción:

;? Patrones de arquitectura: Aquéllos que expresan un esquema organizativo

estructural fundamental para sistemas de software.
;? Patrones de diseño: Aquéllos que expresan esquemas para definir estructuras de
diseño (o sus relaciones) con las que construir sistemas de software.
;? Dialectos: Patrones de bajo nivel específicos para un lenguaje de programación
o entorno concreto.

Además, también es importante reseñar el concepto de "antipatrón de diseño", que con

forma semejante a la de un patrón, intenta prevenir contra errores comunes de diseño en
el software. La idea de los antipatrones es dar a conocer los problemas que acarrean
ciertos diseños muy frecuentes, para intentar evitar que diferentes sistemas acaben una y
otra vez en el mismo callejón sin salida por haber cometido los mismos errores.
Además de los patrones ya vistos actualmente existen otros patrones como el siguiente:
Interacción: Son patrones que nos permiten el diseño de interfaces web.

R
#







 

Para describir un patrón se usan plantillas más o menos estandarizadas, de forma que se
expresen uniformemente y puedan constituir efectivamente un medio de comunicación
uniforme entre diseñadores. Varios autores eminentes en esta área han propuesto
plantillas ligeramente distintas, si bien la mayoría definen los mismos conceptos
básicos.

La plantilla más común es la utilizada precisamente por el GoF y consta de los

siguientes apartados:

;? Nombre del patrón: nombre estándar del patrón por el cual será reconocido en la
comunidad (normalmente se expresan en inglés).
;? Clasificación del patrón: creacional, estructural o de comportamiento.
;? Intención: ¿Qué problema pretende resolver el patrón?
;? También conocido como: Otros nombres de uso común para el patrón.
;? Motivación: Escenario de ejemplo para la aplicación del patrón.

      
4
 c




;? Aplicabilidad: Usos comunes y criterios de aplicabilidad del patrón.

;? Estructura: Diagramas de clases oportunos para describir las clases que
intervienen en el patrón.
;? Participantes: Enumeración y descripción de las entidades abstractas (y sus
roles) que participan en el patrón.
;? Colaboraciones: Explicación de las interrelaciones que se dan entre los
participantes.
;? Consecuencias: Consecuencias positivas y negativas en el diseño derivadas de la
aplicación del patrón.
;? Implementación: Técnicas o comentarios oportunos de cara a la implementación
del patrón.
;? Código de ejemplo: Código fuente ejemplo de implementación del patrón.
;? Usos conocidos: Ejemplos de sistemas reales que usan el patrón.
;? Patrones relacionados: Referencias cruzadas con otros patrones.



 





$%
&$
!
'
%( 

 u




 



;? Abstract Factory (Fábrica abstracta): Permite trabajar con objetos de distintas
familias de manera que las familias no se mezclen entre sí y haciendo
transparente el tipo de familia concreta que se esté usando.
;? Builder (Constructor virtual): Abstrae el proceso de creación de un objeto
complejo, centralizando dicho proceso en un único punto.
;? Factory Method (Método de fabricación): Centraliza en una clase constructora la
creación de objetos de un subtipo de un tipo determinado, ocultando al usuario
la casuística para elegir el subtipo que crear.
;? Prototype (Prototipo): Crea nuevos objetos clonándolos de una instancia ya
existente.
;? Singleton (Instancia única): Garantiza la existencia de una única instancia para
una clase y la creación de un mecanismo de acceso global a dicha instancia.

 



 

;? Adapter (Adaptador): Adapta una interfaz para que pueda ser utilizada por una
clase que de otro modo no podría utilizarla.
;? Bridge (Puente): Desacopla una abstracción de su implementación.
;? Composite (Objeto compuesto): Permite tratar objetos compuestos como si de
uno simple se tratase.
;? Decorator (Envoltorio): Añade funcionalidad a una clase dinámicamente.
;? Facade (Fachada): Provee de una interfaz unificada simple para acceder a una
interfaz o grupo de interfaces de un subsistema.
;? Flyweight (Peso ligero): Reduce la redundancia cuando gran cantidad de objetos
poseen idéntica información.
;? Proxy: Mantiene un representante de un objeto.

      
5
 c




 â



)
) 



;? Chain of Responsibility (Cadena de responsabilidad): Permite establecer la línea
que deben llevar los mensajes para que los objetos realicen la tarea indicada.
;? Command (Orden): Encapsula una operación en un objeto, permitiendo ejecutar
dicha operación sin necesidad de conocer el contenido de la misma.
;? Interpreter (Intérprete): Dado un lenguaje, define una gramática para dicho
lenguaje, así como las herramientas necesarias para interpretarlo.
;? Iterator (Iterador): Permite realizar recorridos sobre objetos compuestos
independientemente de la implementación de estos.
;? Mediator (Mediador): Define un objeto que coordine la comunicación entre
objetos de distintas clases, pero que funcionan como un conjunto.
;? Memento (Recuerdo): Permite volver a estados anteriores del sistema.
;? Observer (Observador): Define una dependencia de uno-a-muchos entre objetos,
de forma que cuando un objeto cambie de estado se notifique y actualicen
automáticamente todos los objetos que dependen de él.
;? State (Estado): Permite que un objeto modifique su comportamiento cada vez
que cambie su estado interno.
;? Strategy (Estrategia): Permite disponer de varios métodos para resolver un
problema y elegir cuál utilizar en tiempo de ejecución.
;? Template Method (Método plantilla): Define en una operación el esqueleto de
un algoritmo, delegando en las subclases algunos de sus pasos, esto permite que
las subclases redefinan ciertos pasos de un algoritmo sin cambiar su estructura.
;? Visitor (Visitante): Permite definir nuevas operaciones sobre una jerarquía de
clases sin modificar las clases sobre las que opera.






  

El primer intento por aplicar este concepto en el diseño de las interfaces de usuario se
dio por Ward Cummingham y Kent Beck quienes adaptaron la propuesta de C.
Alexander y crearon cinco patrones de interfaz: Window per task, Few panes, Standard
panes, Nouns and verbs, y Short Menu. En años más recientes investigadores como
Martin Van Wellie, Jennifer Tidwell, Jaime Muñoz han desarrollado colecciones de
patrones de interacción para la World Wide Web. En dichas colecciones captan la
experiencia de programadores y diseñadores expertos en el desarrollo de interfaces
usables y condensan esta experiencia en una serie de guías o recomendaciones, que
puedan ser usadas por los desarrolladores novatos con el propósito de que en poco
tiempo adquieran la habilidad de diseñar interfaces que incidan en la satisfacción de los
usuarios. Los patrones de interacción buscan la reutilización de interfaces eficaces y un
manejo óptimo de los recursos de las páginas web, haciendo más eficaz el consumo de
tiempo en el diseño del sitio web y permitiendo a los programadores novatos adquirir
más experiencia.

*
+
 

,)
 

Además de su aplicación directa en la construcción de software en general, y derivado

precisamente del gran éxito que han tenido, los patrones de diseño han sido aplicados a

      
6
 c      ?

 

      ?
?

lti l ? 
it ?  t
?  i 
? "l  j
?  ? t
"? ? t 

?
"tl
"? ?l?
? ?i 

? t
?
?
?ti l?
?ti
?l
?
 
? ?l
?
i i t
?
it
:?
?
t
?  ? it 
?  ?
i?
t?
?  ll
?  ? it t?  ii? l
?
j
?


?  ? 
t i? it 
? 
 
 i? t
? ? l? 
t i ?  ?

i
t

?

il
? ?  ?
?   i  ?
 il
?
 
? ? i
t t 
?
 ?
t  ? ? ? i l?  ? 
ti ? i
tt ? ?
i
i? t
? 
? l?

lili?? l?
t i
i t? l?
i
t
?
t
? ? l? it i ?  ?
i
t

?
?  i? ? l? it 
ii ? ?
ii ? ?
i
t

? t  
?
t
?  ? l j
?  ? tj?
t?
? ? l?  iii ? 
t i ? ? it i ?  ?

i
t

? 
tt
?  ? 
ti ?  ? l j
?  ? tj? ? 

? ?
i
t

?


il
??
?
?
†
  

?
l?t?  ? i
?
il t?i
ti?i?
t? i
? ?
tii?l?  i?
 ?j t
? t  i t
?? ?l
?? l? l? ? ?ti?? ?i?j t?
?
! ? it i? 
i
t ? ? ti?  ? ? l
?
l? t ? ? i
ti? ?
i? ? t? ?
?ll?? ll?
?
l? t?
il t?
? i
l
t?  ? ? 
t? l
? ?
t?  ?  ? ?
i
ti? l?j t?
l?
i?t í?? i
t ?l ??
 ? ?l?l
??  ?

? i
ti?  
t ?
?   l? l? l ?  l? 
t t? ? ti t
? 
?
t i??i ?
?
"? i
t
ti?  l? t?   ?
?  li? ? 

? ?
ltil
? il
?  ?
j  i?!i? 
?il
?  ? j  i?it t?  ?l?i
ti? l?
i

?ti
? ?
t?
? i
t ?t í?
l? ? ? ll
?  ?l? ? l?j t?"?
l i?l
i??

t ? l
?
? tili? l
i?
t ? ? l?
t?  ?  i?  ? l? l
?  ?
i
l
t? l?t?
?
"
?
it i
?

? it l
?  ? lii?  ?
t ? t?
?  ll
? ? l
?  ?
i? l
? tl? l? 
? ? ?  
? í
i? i? 
?   ?
? l?t? ? ?
i ?i t? ?
? l
i ?? ?i t?ti? ?t
?  ?
t?i
il ?
?t
?l
?

?j t
? ?l?lii?
?

  

  ?
?
 c




El patrón singleton provee una única instancia global gracias a que:

;? La propia clase es responsable de crear la única instancia.

;? Permite el acceso global a dicha instancia mediante un método de clase.
;? Declara el constructor de clase como privado para que no sea instanciable
directamente.

#)

 !


-

Este código estructural se muestra el patrón Singleton asegura que sólo una instancia
única (el único) de la clase se pueden crear.

M M
 
 
 


 

    



M M M !

M M M "# 
  $ 
 % 

M M M
  & 



M M M M !


 "#

M M M !

M M M
    
  


M M M M !

 ' " ()

M M * +     

, '


 - . 
) / (


 0 . 
) / (

M M
 
  

 (- .. 0)

*
) 12 (32  
  3

M M   $ 


      
8
 c




*
) %5 (

M M M !

M M M 
6
6 


M M M M !


 


+ 
 7 '

M M *  3 3

  
 ()

+ 8
 / 
 ()

M M 9
,  
, ,

M M :;       

 (7 .. 

7 . 
 () '

'
' 7

?
Salida
2  
  

      
9
 c




 
À


Al realizar el presente trabajo de investigación podemos llegar a las siguientes

conclusiones:

;? Los patrones de diseño permiten que una parte del sistema varíe de forma
independiente sin afectar a las demás partes.
;? Además los patrones de diseño ayudan a poder estructurar clases y objetos, de
esa manera resolver problemas y adaptarlos al contexto de la aplicación.
;? La importancia de los patrones de diseño es tal, que los principales ambientes de
desarrollo como NetBeans contienen plug-ins para aplicar a diseños UML de
diagramas de clases patrones de diseño.
;? Por último, debido a que permiten crear sistemas con un acoplamiento débil,
permiten crear sistemas orientados a objetos flexibles, que puedan cambiar ya
que minimizan la interdependencia entre objetos.

      
10
 c




XÀXÀ 
 

;? http://mit.ocw.universia.net/6.170/6.170/f01/pdf/lecture-12.pdf
;? http://www.ingenierosoftware.com/analisisydiseno/patrones-diseno.php
;? http://jmarcost.blogspot.com/2007/03/patrones-de-diseo-singleton.html
;? http://msdn.microsoft.com/es-es/library/bb972240.aspx

      
11
 c




 À 
Introducción ................................ ................................ ................................ .......... 1
Patrones de Diseño ................................ ................................ ............................... 2
1. ¿Qué es un Patrón de Diseño? ................................ ................................ ........... 2
2. Breve Reseña Histórica ................................ ................................ ..................... 2
3. Objetivo de los Patrones ................................ ................................ .................... 3
4. Ventajas de los Patrones ................................ ................................ .................... 3
5. Categorías de los Patrones ................................ ................................ ................. 4
6. Estructuras o Plantillas de los Patrones ................................ .............................. 4
7. Relacion de los principales Patrones G o F ................................ ........................ 6
7.1. Patrones Creacionales................................ ................................ ..................... 6
7.2. Patrones Estructurales ................................ ................................ .................... 6
7.3. Patrones de Comporatmiento ................................ ................................ .......... 6
7.4. Patrones de Interacción................................ ................................ ................... 6
8. Aplicación en Ámbitos Concretos ................................ ................................ ..... 6
9. Singleton ................................ ................................ ................................ ........... 7
Ejemplo de código en C # ................................ ................................ ..................... 9
Conclusiones ................................ ................................ ................................ ....... 10
Bibliografía ................................ ................................ ................................ ......... 11
Índice ................................ ................................ ................................ .................. 12

      
12