Está en la página 1de 30

Patrones de Diseo

Resumen

Emiliano Pereyra
Versin 1.2 11 de agosto de 2009

Indice de contenido
Lista de Cambios................................................................................................................................. 3 Licencia................................................................................................................................................3 Propsito.............................................................................................................................................. 3 Patrones creacionales...........................................................................................................................4 Abstract Factory.............................................................................................................................. 4 Builder.............................................................................................................................................6 Factory Method............................................................................................................................... 7 Prototype......................................................................................................................................... 8 Singleton........................................................................................................................................10 Patrones Estructurales........................................................................................................................ 11 Adapter.......................................................................................................................................... 11 Bridge............................................................................................................................................13 Composite......................................................................................................................................14 Decorator.......................................................................................................................................16 Facade............................................................................................................................................17 Flyweight.......................................................................................................................................19 Proxy............................................................................................................................................. 20 Patrones de Comportamiento.............................................................................................................22 Chain Of Responsibility................................................................................................................22 Command......................................................................................................................................23 Interpreter......................................................................................................................................25 Iterator...........................................................................................................................................26 Mediator........................................................................................................................................ 27 Memento....................................................................................................................................... 28 Observer........................................................................................................................................ 29 State............................................................................................................................................... 31 Strategy......................................................................................................................................... 32 Template Method.......................................................................................................................... 33 Bibliografa........................................................................................................................................ 35

Pg. 2

Lista de Cambios
Iteracin Fecha 0 1 2 Descripcin Autor Emiliano Pereyra

18/12/2006 Versin 1.0

Versin 1.1. Incorporacin de: diagramas con notacin 14/04/2008 UML, y subsecciones aplicacin, consecuencias y Emiliano Pereyra patrones relacionados. 11/09/2009 Versin 1.2. Revisin. Correcciones Ortogrficas. Flavio Robles

Licencia
Este documento est licenciado bajo la licencia Attribution-ShareAlike 2.5 Argentina de Creative Commons, disponible en http://creativecommons.org/licenses/by-sa/2.5/ar/.

Propsito
El propsito de este documento es el de servir de referencia rpida de los conceptos de diseo orientado a objetos y patrones de diseo que se encuentran en el famossimo libro de GoF1[Gamma95]. Ante cualquier duda, por favor remitirse a dicha publicacin.

1 Gang of Four, trmino con el que se conoce a los autores del libro.

Pg. 3

Patrones creacionales
Los patrones de diseo creacionales abstraen el proceso de instanciacin, ayudando al sistema a independizarse de cmo sus objetos son creados, compuestos y representados. Este tipo de patrones ponen su nfasis en dos de los principales conceptos del diseo orientado a objetos: encapsulacin y ocultamiento de informacin. Todos los patrones creacionales encapsulan el conocimiento acerca de cmo se crean las clases concretas del sistema. Al mismo tiempo, ocultan los detalles de cmo las instancias de dichas clases son creadas y relacionadas entre s. Este tipo de patrones dan mucha flexibilidad en cuanto a lo qu se est creando, quin lo est haciendo, cmo lo hace, y cundo. Esta flexibilidad tambin tiene que ver con que permiten configurar un sistema a partir de objetos productos que pueden variar ampliamente en su estructura y funcionalidad, y en donde dicha configuracin puede ser esttica (en tiempo de compilacin) o dinmica (en tiempo de ejecucin). Para finalizar, cabe destacar que los patrones creacionales estn ntimamente realcionados entre s, de modo que se debe prestar especial atencin a sus diferencias y similitudes.

Abstract Factory Intencin


Proporciana una interfase para la creacin de familias de objetos dependientes o relacionados sin especificar sus clases concretas.

Aplicacin
Este patrn se usa cuando: un sistema debera ser independiente de como sus objetos son creados, ensamblados y representados. un sistema debera ser configurado con una de varias familias de productos. una familia de productos es diseada para utilirse como un todo y se quiere forzar esa restriccin.

Pg. 4

Estructura

Consecuencias

Aisla a las clases concretas. Permite que el cambio de familias de productos sea sensillo. Promueve la consistencia entre productos.

Patrones relacionados
Las clases AbstractFactory a menudo se implementan con mtodos factory (Factory Method) pero tambin podran ser implementadas usando prototipos (Prototype). La clase ConcreteFactory a menudo es un singleton (Singleton).

Builder Intencin
Separa la construccin de un objeto complejo de su representacin, de manera que el mismo proceso de construccin puede crear diferentes representaciones.

Pg. 5

Aplicacin
Este patrn se usa cuando: el algoritmo para crear un objeto complejo debera ser independiente de las partes que forman dicho objeto y de cmo estas son ensambladas. el proceso de construccin debera permitir diferentes representaciones para el objeto que se desea construir.

Estructura

Consencuencias

Permite variar la representacin interna de un producto. Aisla el cdigo para construccin y representacin. Proporciona un profundo control sobre el proceso de construccin.

Patrones relacionados
El AbstractFactory es similar al Builder en que tambin construye objetos complejos. La principal diferencia es que el Builder se enfoca en construir objetos complejos paso a paso, mientras que el AbstactFactory pone nfasis en familias de productos. El Builder devuelve el producto en el paso final; el AbstractFacotory lo hace imediatamente. Un Composite es lo que a menudo el Builder construye.

Pg. 6

Factory Method Intencin


Define una interfase para crear un objeto, pero deja que las subclases decidan que clases instanciar. Factory Method permite a una clase posponer su instanciacin a las subclases.

Aplicacin
Este patrn se utiliza cuando:

una clases no puede anticipar la clase de objeto que debe crear. una clase quiere que sus subclases especifiquen que objetos crear. clases delegan la resposabilidad a una de varias subclases auxiliares, y se quiere localizar el conocimiento de cual subclases auxiliar es la delegada.

Estructura

Consencuencias

Elimina la necesidad de dejar ligadas las clases especficas de la aplicacin dentro del cdigo. Proporciona flexibilidad a la hora de crear clases dentro de la aplicacin. Una desventaja potencial es que un cliente puede tener que subclasificar la clase Creator slo para crear un objeto particular ConcreteProduct. Conecta jerarqua de clases paralelas, la de las fbricas y la de lo que dichas fbricas crean.

Patrones relacionados
El patrn Abstract Factory es a menudo implementado con factory methods. Los factory methods son usualmente llamados dentro del patrn Template Method . El patrn Prototype no requiere subclasificar un Creator. Sin embargo, a menudo requiere una Pg. 7

operacin de inicialize() en la clase Product. La clase Creator utiliza inicialize() para inicializar el objeto. Factory Method no requiere tal operacin.

Prototype Intencin
Especifica el tipo de objetos a crear usuando una instancia prototpica, y creando nuevos objetos copiando este prototipo.

Aplicacin
Se utiliza el patrn Prototype cuando un sistema debe ser independiente de como sus productos son creados, compuestos y representados; y

cuando las clases a inicializar son especificadas en tiempo de ejecucin, por ejemplo, por carga dinmica; o para evitar construir una jerarqua de clases de factorias paralela a la jerarqua de clases del producto.; o cuando instancias de una clase pueden tener slo una de diferentes combinaciones de estado. Puede ser ms conveniente instalar los prototipos que sean necesarios en lugar de inicializar manualmente cada instancia y su correspondiente estado.

Estructura

Consecuencias

Agrega y quita productos en tiempo de ejecucin. Specifica nuevos objetos variando valores. Specifica nuevos objetos variando la estructura. Reduce la subclasificacin. Configura una aplicacin con clases dinmicamente.

Pg. 8

Patrones relacionados
Prototype y Abstract Factory son patrones que ciertos aspectos compiten entre si, pero sin embargo, tambin pueden utilizarse en forma conjunta. Un Abstract Factory puede almacenar un conjunto de prototipos desde los cuales clonar y devolver objetos producto. Los diseos que hagan un fuerte uso de los patrones Composite y Decorator a menudo pueden beneficiarse tambin del Prototype.

Singleton Intencin
Asegura que una clase slo tenga una instancia, y proporciona un punto global de acceso a sta.

Aplicacin
El patrn Singleton se utiliza cuando

debe existir una nica instancia de una clase, y la misma debe ser accedida a travs de un punto de acceso bien conocido. una nica instancia debera ser extendida por subclasificacin, y los clientes deberan ser capaces de utilizar una instancia extendida sin modificar su cdigo.

Estructura

Consencuencias

Controlar el acceso a la nica instancia. Reducir el espacio de nombres. Permite refinamiento de operaciones y representaciones. Permite un nmero variable de instancias. Ms flexible que las operaciones de clase.

Pg. 9

Patrones relacionados
Muchos patrones pueden implementarse utilizando el patrn Singleton. Ver Abstract Factory, Builder, y Prototype.

Pg. 10

Patrones Estructurales
Los patrones estructurales se ocupan de cmo las clases y los objetos son compuestos para formar grandes estructuras. Los patrones estructurales de clase usan herencia para realizar la composicin de interfases o de implementacines. Por su parte, los patrones estructurales de objeto describen la forma de componer objetos para lograr nueva funcionalidad. El agregado de la flexibilidad de la composicin de objetos viene de la habilidad para cambiar la composicin en tiempo de ejecucin.

Adapter Intencin
Convierte la interfase de una clase en otra interfase que el cliente espera. Adapter permite a clases, que de otra manera no podran hacerlo debido a su incompatibilidad de interfases, que trabajen juntas.

Aplicacin
Usar el patrn Adapter cuando:

se quiere utilizar una clase existente y su interfase no machea con la que se necesita. se quiere crear una clase reusable que coopere con clases no relacionadas o imprevistas, esto es, con clases que no tengan necesariamente la misma interfase. se quiere utilizar varias subclases existentes, pero no es viable adaptar sus interfaces subclasificando cada una, de modo que se utiliza un objeto adapter para adaptar la interface de la superclase.

Estructura

Pg. 11

Consecuencias

Permite a un nico Adapter trabajar con varios Adaptees. El Adapter puede tambin agregar funcionalidad a todos los Adaptees a la vez. Es difcil redefinir el comportamiento del Adaptee, y en caso de ser necesario, se tiene que subclasificar el Adaptee y hacer que el Adapter se refiera a la subclase en lugar de al Adaptee.

Patrones relacionados
El Bridge tiene una estructura similar al Adapter de objetos, pero sus intents son diferentes. El Decorator realza otro objeto sin cambiarle su interfase, por lo que ste es ms transparente para la aplicacin de lo que lo es el Adapter. Como consecuencia, el Decorator soporta composicin recursiva, lo cual es imposible con Adapters puros. El Proxy define un objeto representativo o sustituto para otro sin cambiarle su interfase.

Bridge Intencin
Desacopla una abstraccin de su implementacin, de manera que ambas puedan variar independientemente.

Aplicacin
El patrn Bridge se utiliza cuando:

se quiere evitar un ligamiento permanente entre una abstraccin y su implementacin. De esta manera, es posible que la implementacin pueda ser seleccionanda o cambiada en tiempo de ejecucin. tanto las abstracciones subclasificacin. cmo las implementacines deberan ser extendidas por

el cambio de una implementacin no debera impactar en los clientes de la abstracin - evita recompilar cdigo. se tiene un crecimiento muy grande de una jerarqua de clases, lo que indica que se debe partir dicha jerarqua. se quiere compartir una implementacin entre varios objetos y que esto sea transparente a los clientes.

Pg. 12

Estructura

Consecuencias
El patrn Bridge tiene las siguientes consecuencias:

Desacopla una intefase de su implementacin. Mejora la extensibilidad. Oculta los detalles de implementacin de los clientes.

Patrones relacionados
Un Abstract Factory puede crear y configurar un Bridge particular. El patrn Adapter est pensado para hacer que clases no relacionadas trabajen juntas. Este es aplicado generalmente en sistemas despus de diseados. Por otro parte, el patrn Bridge es usado durante el diseo para permitir que las abstracciones y las implementacines varien independientemente.

Composite Intencin
Compone objetos en estructuras de rbol para representar jerarquas todo-parte. Composite permite a los clientes tratar objetos individuales y compuestos de un objeto de manera uniforme.

Aplicacin
Se utiliza el patrn Composite cuando:

se quiere representar jerarquas todo-parte de objetos. se quiere que los clientes sean capaces de ignorar las diferencias entre composiciones de objetos y objetos individuales.

Pg. 13

Estructura

Consecuencias

Los objetos primitivos pueden ser compuestos en objetos ms complejos, los cuales a su vez pueden ser compuestos en otros, y as recursivamente. Hace a los clientes simples, adems de permitirles tratar a estructuras compuestas y a objetos individuales de la misma manera. Facilita el agregado de nuevos tipos de componentes. Puede hacer que el diseo sea demasiado general. La desventaja de facilitar el agregado de nuevos componentes es que es difcil restringir los componentes del composite. Con este tipo de estructuras se tienen que realizar chequeos en tiempo de ejecucin para forzar las restricciones. A nivel de diseo se podra emplear algn tipo de notacin por ejemplo, OCL2para expresar dichas restricciones.

Patrones relacionados
A menudo se utilizan enlaces componente-padre para un Chain of Responsibility. El patrn Decorator se usa habitualmente con Composites, los cuales se relacionan con una superclase. Por lo tanto, los Decorators tendran que soportar la interfase Component con operaciones como add(Component c), remove(Component c), y getChild(int index). El Flyweight permite compartir componentes, pero con la limitacin de no mantener referencias al padre. El Iterator puede ser utilizado para recorrer composites. El Visitor localiza operaciones y comportamiento que de otra manera estara distribuido entre las clases Composite y Leaf.
2 Object Constraint Language (Lenguaje de restriccin de objetos)

Pg. 14

Decorator Intencin
Agrega responsabilidades adicionales a un objeto dinmicamente. Los Decorators proveen un altenativa flexible a la subclasificacin para extender funcionalidad.

Aplicacin
Usar un Decorator

para agregar responsabilidades a objetos individuales dinmicamente y de forma transparente, esto es, sin afectar a otros objetos. para implementar responsablidades que pueden removidas. cuando la extencin por subclasificacin es poco prctica.

Estructura

Consecuencias

Mayor flexibilidad que una herencia esttica. Evita clases cargadas de funcionalidad en lo alto de la jerarqua. Un decorador y sus componentes no son idnticos. Mucha cantidad de objetos pequeos.

Pg. 15

Patrones relacionados
Adapter: Un decorator difiere de un adapter en que el decorator slo cambia las responsabilidades de un objeto, no su interfase; un adapter le d al objeto una interfase completamente nueva. Composite: Un decorator se puede ver como un composite degenerado con un solo componente. Strategy: Un decorator permite cambiar la apariencia de un objeto; un strategy permite cambiar su interior.

Facade Intencin
Proporciona un interfase unificada a un conjunto de interfases en un subsistema. Facade define un interfase de alto nivel que hace al subsistema fcil de usar.

Aplicacin
Usar el patrn Facade cuando

se necesita proporcionar un interfase simple a un subsistema complejo. existen muchas dependencias entre los clientes y las clases de implementacin de las abstracciones se quiere implementantar los subsistemas en capas.

Estructura

Pg. 16

Consecuencias

Reduce el nmero de objetos con los que los clientes de un subsistema tienen que conocer, haciendo que dicho subsistema sea fcil de utilizar. Promueve el bajo acoplamiento entre el subsistema y los clientes del mismo. No impide que las aplicaciones usen las clases del subsistema si estas lo requieren.

Patrones relacionados
El Abstract Factory se puede usar con Facade para proporcionar un interfase para la creacin de objetos de un subsistema de forma independiente del subsistema. El Mediator es similar al Facade en que ambos abstraen funcionalidad de clases existentes. Sin embargo, el propsito del Mediator es encapsular la comunicacin entre objetos y el del Facade es proporcionar una interface de acceso a un subsistema. Usualmente slo se necesita un objeto Facade, con lo que dichos objetos a menudo son Singletons.

Flyweight Intencin
Uso de comparticin para soportar un gran nmero de objetos de granuralidad fina efectivamente.

Aplicacin
La efectividad de ste patrn depende de como y donde se usa. Para aplicar el Flyweight se tienen que cumplir todo lo que sigue:

Una aplicacin que usa una gran cantidad de objetos. Los costos de almacenamiento son altos debido a la cantidad de objetos. La mayora de los estados de los objetos pueden ser hechos extrnsecos. Muchos grupos de objetos pueden reemplazarse por relativamente unos pocos compartidos una vez que el estado extrnseco es quitado. La aplicacin no depende la identidad de esos objetos. objetos

Pg. 17

Estructura

Consecuencias
Los Flyweights pueden introducir costos de tiempo de ejecucin asociados con transferencia, busqueda y/o clculo de estados extrnsecos. El ahorro de almacenamiento es una funcin de los siguientes factores:

Reduccin del nmero total de instancias que vienen de la comparticin. Cantidad de estados intrnsicos por objetos. Si el estado extrnsico es calculado o almacenado.

Patrones relacionados
El patrn Flyweight a menudo se combina con el patrn Composite para implementar una estructura lgica jerrquica en trminos grafos dirigidos aciclcos con nodos hojas compartidos. Una de las mejores maneras de implementar objetos State y Strategy es a travs de flyweights.

Proxy Intencin
Proporciona un sustituto o contenedor para otro objeto para as controlar el acceso a ste.

Aplicacin
El patrn Proxy es aplicable en cualquier lugar donde se necesite una referencia ms sofisticada y verstil que un simple puntero. Algunas de las aplicaciones ms comunes de este patrn son:

Proxy remoto: proporciona un representacin local de un objeto que se encuentra en un espacio

Pg. 18

de direcciones distinto.

Proxy virtual: crea objetos pesados bajo demanda. Proxy de proteccin: controla el acceso al objeto original.

Estructura

Consecuencias
Este patrn introduce un nivel de indireccin cuando se accede a un objeto. El uso de esta indireccin vara segn el tipo de proxy:

Un proxy remoto puede ocultar el hecho de que un determinado objeto reside en un espacio de direcciones diferente. Un proxy virtual puede realizar optimizaciones tales como la creacin de objetos bajo demanda.

Patrones relacionados
Adapter: se puede utilizar para adaptar las interfaces entre el RealSubject y el Proxy, sobre todo cuando se implementa un proxy de proteccin, en donde algunas operaciones del objeto real no pueden ser ejecutadas por el proxy. Decorator: aunque los decorators tienen un implementacin similar que los proxies, ambos tienen propsitos distintos: uno tiene el propsito de agregar funcionalidad dinmicamente y el otro de controlar el acceso a objetos.

Pg. 19

Patrones de Comportamiento
Los patrones de comportamiento estn relacionados con los algoritmos y la asignacin de responsabilidades entre objetos. Dichos patrones describen no slo clases y objetos sino tambin la comunicacin entre stos. Los patrones de comportamiento de clase utilizan herencia para distribuir el comportamiento entre las clases, mientras que los de objeto hacen uso intensivo de composiciones ms que de herencia.

Chain Of Responsibility Intencin


Evita acoplar el emisor de una solicitud con su receptor dando a ms de un objeto la posibilidad de manejar la solicitud. Los objetos receptores pasan la solicitud a travs de la cadena hasta que un objeto la maneje.

Aplicacin
Este patrn se utiliza cuando:

ms de un objeto pude manejar una solicitud, y dicho objeto no se conoce a priori. se quiere enviar una solicitud a uno de varios objetos sin especificar el receptor explicitamente. el conjunto de objectos que pueden manejar una solicitud debera ser especificado dinmicamente.

Estructura

Pg. 20

Consecuencias

Reduce el acoplamiento. Agrega flexibilidad en la asignacin de responsabilidades a los objetos. El receptor de las solicitudes no est garantizado.

Patrones relacionados
Este patrn a menudo es aplicado en conjuncin con Composite, donde el componente padre acta como su sucesor.

Command Intencin
Encapsula una solicitud como un objeto, permitiendo parametrizar los clientes con diferentes solicitudes, y soportando operaciones de deshacer.

Aplicacin
El patrn Command se utiliza cuando se quiere:

parametrizar objetos con un accin para que la ejecuten. especficar, encolar y ejecutar solicitudes en diferentes tiempos. soportar operaciones de deshacer (undo). soportar el registro de los cambios realizados para que se reapliquen en caso de un fallo de sistema. estructurar un sistema alrededor de operaciones de alto nivel contruidas a partir de operaciones primitivas. Esta estructura es tpica en sistemas que soportan transacciones.

Pg. 21

Estructura

Consecuencias

Descopla el objeto que realiza la invocacin del que conoce como ejecutarla. Se pueden ensamblar commands dentro de un composite command (operaciones complejas). Es fcil agregar nuevos commands debido a que no se tienen que modificar las clases existentes.

Patrones relacionados
El patrn Composite se puede utilizar para implementar un macro command. El patrn Memento puede mantener el estado que un command necesita para soportar operaciones de deshacer (undo). Un command que debe copiarse antes de ser ubicado en un lista histrica acta como un Prototype.

Interpreter Intencin
Dado un lenguaje, define una representacin para su gramtica junto con un intrprete que usa la representacin para interpretar las sentencias en el lenguaje.

Aplicacin
Este patrn se utiliza cuando existe un leguaje a interpretar, y se quiere representar las sentencias del mismo como un rbol de sintaxis abstracto. Intepreter funciona bien cuando:

la gramtica es simple. la eficiencia no es una cuestin crtica.

Pg. 22

Estructura

Consecuencias

Es fcil cambiar y extender la gramtica. La implementacin de la gramtica tambin es sensilla. Las gramticas complejas son difciles de mantener. Es sencillo agregar una nueva forma de interpretar una expresin.

Patrones relacionados
El rbol de sintxis abstracto es una instancia del patrn composite. El patrn Flyweight muestra como compartir los smbolos terminales dentro del rbol de sintxis abstracto. El patrn Iterator puede usarse para recorrer la estructura de rbol.

Iterator Intencin
Proporciona una forma de acceder secuencialmente a los elementos de un objeto coleccin sin exponer su representacin subyacente.

Aplicacin
El patrn Iterator se aplica para:

acceder al contenido de un objeto coleccin sin exponer su represetancin interna. soportar mltiples recorridos de un objeto coleccin. proporcionar un interfase uniforme para recorrer diferentes estructuras de colecciones (soportar una interaccin polimrfica)

Pg. 23

Estructura

Consecuencias

Soporta variaciones en el recorrido de objetos tipo coleccin. Los iterators simplifican la interfase de objeto tipo coleccin. Se pueden tener pendientes ms de un recorrido sobre un objeto tipo coleccin.

Patrones relacionados
Los Iterators a menudo son aplicados a estructuras recursivas como lo son los Composites. Los Iterators polimrficos confan en los factory methods para instanciar la subclase apropiada del iterator. El patrn Memento se utiliza a menudo en conjuncin con el patrn Iterator para capturar el estado de la iteracin. El Iterator almacena los mementos internamente.

Mediator Intencin
Define un objeto que encapsula como interactan un conjunto de objetos. El Mediator promueve el bajo acoplamiento manteniendo referencias explcitas entre los objetos, permitindoles variar su interaccin independientemente.

Aplicacin
El patrn Mediator se aplica cuando:

Pg. 24

un conjunto de objetos se comunican de un modo bien definido pero complejo. es dificultoso el reuso de un objeto debido a que este referencia y se comunica con muchos otros objetos. un comportamiento que est distribuido entre varias clases debera ser adaptable sin mucha subclasificacin.

Estructura

Consecuencias

Limita la subclasificacin. Desacopla a los colegas. Simplifica el protocolo de los objetos. Abstrae como los objetos cooperan entre s. Centraliza el control.

Patrones relacionados
El patrn Facade difiere del Mediator en que el primero utiliza un protocolo de comunicacin unidireccional (los objetos facade realizan solicitudes a las clases del subsistema y no a la inversa), mientras que el segundo si lo permite. Los colegas en el patrn Mediator pueden comunicarse utilizando el patrn Observer.

Memento Intencin
Sin violar la encapsulacin, captura y externaliza el estado interno de un objeto, de manera que el objeto puede ser restaurado a ese estado posteriormente.

Pg. 25

Aplicacin
Este patrn se utiliza cuando:

se debe almacenar una imagen del estado de un objeto para luego restaurarlo a dicho estado; y una interfase directa para obtener el estado expondra detalles de implementacin que romperan la encapsulacin.

Estructura

Consecuencias

Preserva la encapsulacin. Simplifica el originator. El uso de mementos puede ser costoso.

Patrones relacionados
El patrn Command puede usar mementos para mantener el estado para operaciones de deshacer. Lo mementos se utilizan en el patrn Iterator para mantener el estado de la iteracin.

Observer Intencin
Define una dependencia uno a muchos entre objetos de modo que cuando un objeto cambia su estado, sus dependientes son notificados y actualizados automticamente.

Aplicacin
Este patrn se utiliza en cualquiera de estas situaciones:

Cuando una abstraccin tiene dos aspectos, uno dependiente del otro. Encapsular estos aspectos en objetos separados permite variarlos y reusarlos de forma independiente. Cuando el cambio de un objeto requiere el cambio de otros, y no se conoce la cantidad de objetos que deben actualizarse.

Pg. 26

Cuando un objeto debera notificar a otros objetos sin hacer suposiciones acerca de cules son esos objetos.

Estructura

Consecuencias

Acoplamiento abstracto entre el Subject y el Observer. Soporta la emisin masiva de solicitudes sin especificar los receptores (broadcast). Actualzaciones inesperadas.

Patrones relacionados
Mediator: A travs de la encapsulacin de una semtica compleja de actualizacin, un clase ChangeManager puede actuar como mediator entre subjects y obervers. Dicho ChangeManager se puede implementar como Singleton para hacerlo nico y que el mismo pueda accederse de forma global.

State Intencin
Permite a un objeto alterar su comportamiento cuando su estado interno cambia. El objeto cambiar su clase de estado.

Aplicacin
Este patrn se utiliza en alguno de los siguientes casos: Pg. 27

El comportamiento de un objeto depende de su estado, y dicho objeto debe cambiar su comportamiento en tiempo de ejecucin dependiendo de su estado. Las operaciones de un objeto poseen sentencias condicionales grandes y complejas que dependen del estado del mismo.

Estructura

Consecuencias

Localiza el comportamiento especfico de estado y a su vez particiona el comportamiento para diferentes estados Hace explcita la transicin de estados. Los objetos de estado se puede compartir.

Patrones relacionados
El patrn Flyweight explica cmo y cundo los objetos State se pueden compartir. Los objetos State a menudo son Singletons.

Strategy Intencin
Define una familia de algoritmos, encapsulando cada uno y hacindolos intercambiables. El Strategy permite al algoritmo variar independientemente de los clientes que los usan.

Aplicacin
El patrn Strategy se utiliza cuando:

muchas clases relacionadas slo difieren entre s por su comportamiento. se necesitan diferentes variantes de un algoritmo.

Pg. 28

un algoritmo utiliza datos que los clientes del mismo no deberan conocer. una clase define varios comportamientos y estos aparecen en mltiples sentencias condicionales en sus operaciones.

Estructura

Consecuencias

Crea familias de algoritmos relacionados. Es una alternativa a la subclasificacin. Los objetos strategies eliminan las sentencias condicionales. Proporciona diferentes implementacines para el mismo comportamiento. Los clientes deben conocen a los distintos strategies. Existe una sobrecarga en la comunicacin entre los objetos strategies y el context. Se incrementa el nmero de objetos.

Patrones relacionados
Los objetos Strategies a menudo pueden ser flyweights.

Template Method Intencin


Define el equeleto un algoritmo en una operacin, difiriendo algunos pasos a las subclases. Deja que las subclases redefinan ciertos pasos sin cambiar la estructura del algoritmo.

Aplicacin
Este patrn debera usarse:

para implementar las partes invariantes de un algoritmo y dejar que las subclases implementen el comportamiento que si vara. cuando el comportamiento entre las subclases debera factorizarse y ubicarse en una clase Pg. 29

comn para evitar cdigo duplicado.

para controlar la subclasificacin; se define un template method que llama a las operaciones hook3 en puntos especficos de la aplicacin, permitiendo las extensiones de comportamientos solo en estos puntos.

Estructura

Consecuencias
El patrn Template Method es una tcnica fundamental para el reuso de cdigo, facilitando la estructura necesaria para aplicar lo que se denomina inversin del control. Los templates method llaman a los siguientes tipos de operaciones:

operaciones concretas. operaciones abstractas o primitivas. mtodos factory (ver Factory Method). operaciones hook.

Patrones relacionados
El patrn Factory Method es un caso particular de Template Method.

Bibliografa
[Gamma95] Eric Gamma, Richard Helm, Ralph Johnson, y John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley, 1995. [Fowler99] Martin Fowler. UML gota a gota. Addison-Wesley, 1999.
3 Se mantiene el trmino en ingls por razones de entendibilidad. Tambin se pueden denominar hotspots o puntos de extensin.

Pg. 30