Mostrando entradas con la etiqueta patrones de diseño. Mostrar todas las entradas
Mostrando entradas con la etiqueta patrones de diseño. Mostrar todas las entradas

miércoles, 12 de octubre de 2011

Herencia de clases y el "Principio de Liskov"

En realidad se llama "Principio de sustitución de Liskov" y el nombre completo es Bárbara H. Liskov (sí, hay mujeres en la informática y han hecho grandes aportes ;-)).

A grandes rasgos dice que el famoso "es un" (is_a) que generalmente usan los docentes para enseñarnos "herencia de clases" no es suficiente.

No basta con "ser" hay que "comportarse como tal".


Generalmente hago el mismo chiste cuando trato el tema en un curso: "un docente es una persona, pero no basta, debe comportarse como tal".

Un ejemplo más real: Sistema de liquidación de sueldos

Si tienes un sistema que liquida sueldos, una clase base Empleado (con atributos como "sueldo" que se usa para calcular su pago) y subclases Gerente, Desarrollador, Administrativa y Becario (asumamos que el último no recibe ninguna remuneración).

Usas polimorfismo y en tu clase Administracion tienes un método liquidarSueldo donde recibirás objetos de tipo Empleado. Bien, cuando en un momento recibes de tu lista de empleados un becario... ¿qué debe hacer el sistema? (ya que haces el cálculo en base al valor que viene en el atributo sueldo y este es heredado por todos desde la clase Empleado).
  1. ¿Emitir un comprobante impreso pero con valor 0?
  2. ¿Agregar un "if" preguntando si es becario, y no hacer nada?
  3. etc

Supongamos que el 1) no es aceptable por el gasto de papel y te piden que no se impriman (no tiene sentido), pasamos al punto 2), agregamos un "if".

¿No estamos "codificando a fuego" nuestro sistema para un comportamiento particular?

Estamos rompiendo el polimorfismo, justamente, el patrón estratégico más importante que tiene la POO. Cada vez que tenemos que cambiar nuestro código generamos nuevos costos y nuevos posibles errores.

Por eso cada vez nos cuesta más desarrollar un sistema, hasta que tenemos que tirarlo y desarrollar otro de cero... y empezamos otra vez con los problemas del mal diseño (code smell).

La base teórica

Los principios de diseño te dicen que "desarrolla cerrado al cambio y abierto a la extensión" (Principio Open/Closed, "Abierto / Cerrado").

Por ejemplo, tu código debe ser reutilizable (¿no es la idea esencial de la OO?) y con solo agregar código -sin tocar el existente- lograrás adecuarte a los cambios, a los nuevos requerimientos. No te olvides que nuestro código lo usan muchos otros objetos, si este cambiara, generaría un efecto en cadena, posiblemente, dejando de funcionar lo ya existente y tener que modificar más objetos.

Esta forma de "extensión" es agregar más clases a la herencia y el método liquidarSueldo no se modifica, pero si tu no haces correctas herencias, no puedes hacer lo primero, por lo tanto tu sistema se degradará en cascada.

Esta simple tontería el autor demuestra con muchos ejemplos que hacer "herencia por herencia", "por reutilizar código", no es suficiente y genera grandes problemas en los diseños.

Es una de las razones que me ven de mal humor cuando veo que implementan herencia a los golpes, prueba y error, con el argumento solo de "reutilizar código"

La conclusión final es...

El problema es que la herencia está mal formulada y que el Becario no se comporta como un Empleado, por lo tanto no puede ir en esa estructura jerárquica, de lo contrario nos va a obligar a desarmar nuestro sistema para tratar de ajustarlo a un comportamiento no adecuado (agregando condiciones explícitas para el mismo, hardcode) y este empezará a dejar de ser reusable.

No se puede hacer herencia por herencia, para reusar código. No se puede hacer herencia simplemente por que un "Becario es un Empleado", hay que estar seguro que además de "ser" se comporte como tal.

Nuestro becario, ya que no cobra una remuneración, no pude pasar por el sistema de liquidación de sueldos. La solución no es ajustar el sistema de sueldos para que lo permita.

Anexo otro artículo relacionado: Herencia Múltiple en PHP5

Nota: este post está basado en una discusión presentada en Foros del Web

Fuente: http://phpsenior.blogspot.com/2007/10/herencia-de-clases-y-el-principio-de.html

miércoles, 5 de octubre de 2011

Patron Type Object

(updated version in spanish here)

Desacopla instancias de sus clases para que estas puedan ser implementadas como una instancia de una clase. Type Object permite crear nuevas clases dinámicamente en tiempo de ejecución porque estas son instancias, y también permite al sistema crear instancias de esas class-like instancias.
A veces una clase no solo requiere un numero desconocido de instancias, sino que tambien una cantidad desconocida de subclases, Un objecto puede crear nuevas instancias, pero usualmente no puede crear nuevas clases sin tener que recompilar.

Cuando usar este patron?
-Las instancias de una clase necesitan estar agrupadas para implementar el comportamiento o los atributos del grupo.
-La clase necesita una subclase por cada grupo para implementar los atributos/comportamientos del grupo.
-La clase requiere una gran cantidad de subclases y/o la variedad total de subclases que quizas se requieren se desconoce
-Se necesita poder crear nuevas agrupaciones en tiempo de ejecucion que quizas no se predijeron durante el diseño.
-Se necesita poder cambiar una subclase de un objeto despues de que se instancio sin tener que mutar a una nueva clase.
-Se necesita jerarquizar los grupos recursivamente de modo que ese grupo sea a su vez un item de otro grupo.

miércoles, 14 de julio de 2010

dealing with properties (Propiedades dinamicas) por Martin Fowler

Casi todos los objetos que crean necesidades propiedades: alguna declaración sobre el objeto. Una persona puede tener una altura, una empresa puede tener un director general, un vuelo puede tener un número de vuelo. Hay un número de maneras de propiedades de modelo. En este artículo exploraremos algunas de estas formas y cuando es posible que desee utilizarlos. A menudo he visto tocar patrones sobre este tema, pero por lo general sólo cubren una parte del cuadro. Aquí quiero referirme a la cuestión de manera más amplia para dar una mejor discusión de las opciones. El más común, y el caso más simple es utilizar una propiedad fija, que es justo declarar el atributo de la clase. En la gran mayoría de los casos eso es todo lo que necesita hacer. propiedades fijas comienzan a fallar cuando se tiene una gran cantidad de ellos, o si necesita cambiar con frecuencia, posiblemente en tiempo de ejecución. Estas fuerzas que conducen a la dinámica de las variedades de la Propiedad. Todas las propiedades dinámicas tienen la cualidad de un atributo parametrizado donde consultar una propiedad que usted necesita usar un método de consulta con un parámetro. El más simple es la propiedad dinámica flexible donde el parámetro es una cadena. Esto hace que sea fácil de definir y utilizar las propiedades, pero es difícil de controlar. Si necesita que el control se puede utilizar una propiedad dinámica definida en sus parámetros deben ser las instancias de alguna clase. Un paso más allá del control le permite escribir firmemente su propiedad dinámica con una propiedad con tipo dinámico. A medida que su estructura de la propiedad se involucren más, usted debería considerar la posibilidad de separar las propiedades, lo que hace que la propiedad de un objeto por derecho propio. Si usted necesita de valores múltiples propiedades que se pueden considerar una relación con tipo. En el ejemplo más complejo de este tema es donde usted quiere reglas para controlar los tipos de objetos tienen qué tipo de propiedades - esto exige una dinámica de la propiedad del conocimiento de nivel. Otra variedad de la propiedad por completo es el de propiedad extrínseca, un patrón que usar si se desea dar a un objeto una propiedad, pero sin alterar su interfaz para apoyarla. Problema Solución página Nombre Dale un atributo específico de este hecho. Esto se traducirá en un método de consulta y, probablemente, un método de actualización en un lenguaje de programación.

Fuente (Ingles) : http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.73.6208

martes, 15 de junio de 2010

Diferencia entre Strategy y Template Method.

el patron estrategia lo que usas es una delegacion, por lo que es mucho mas flexible que el patron Template que se ìmplementa con herencia (para poder definir los detalles de
los metodos que te permite redefinir). En los dos tenes polimorfismo, pero
el Estrategia es mas flexible..(en estrategia cuando se delega, los detalles
se definen en tiempo de ejecucion mientras que en Template es en tiempo de
compilacion)..espero que te sirva!
un saludo!



[Mat7507f] Diferencia etre Strategy y Template Method.

martes, 8 de junio de 2010

Proxy (patrón de diseño)


El patrón Proxy se utiliza como intermediario para acceder a un objeto, permitiendo controlar el acceso a él.

Problema que soluciona
Necesitamos crear objetos que consumen muchos recursos, pero no queremos instanciarlos a no ser que el cliente lo solicite o se cumplan otras condiciones determinadas.

Participantes y Relaciones
Subject: Interfaz o clase abstracta que proporciona un acceso común al objeto real y su representante (proxy).

Proxy: Mantiene una referencia al objeto real. Controla la creación y acceso a las operaciones del objeto real.

RealSubject: Define el objeto real representado por el Proxy.

Implementación
Tenemos un objeto padre Asunto del que heredan otros dos:AsuntoReal y Proxy, todos ellos tienen un método petición(). El cliente llamaría al método petición() de Asunto, el cual pasaría la petición a Proxy, que a su vez instanciaría AsuntoReal y llamaría a su petición().

Esto nos permite controlar las peticiones a AsuntoReal mediante el Proxy, por ejemplo instanciando AsuntoReal cuando sea necesario y eliminándolo cuando deje de serlo.



Proxy (patrón de diseño) - Wikipedia, la enciclopedia libre

Decorator (patrón de diseño)

El patrón Decorator AHIJAT responde a la necesidad de añadir dinámicamente funcionalidad a un Objeto. Esto nos permite no tener que crear sucesivas clases que hereden de la primera incorporando la nueva funcionalidad, sino otras que la implementan y se asocian a la primera.



Problema que soluciona
Supongamos que tenemos una clase existente Ventana y queremos añadirle funcionalidad para que muestre un borde alrededor. Podemos crear una subclase VentanaConBorde que herede de Ventana.

Hasta aquí todo bien, pero supongamos que surge la necesidad de crear una ventana que muestre un pequeño botón de ayuda con un signo de interrogación (?) en su parte superior. Entonces tenemos las siguientes opciones:

Crear otra subclase de Ventana: VentanaConBotónDeAyuda.
Problema: No cubre la necesidad de tener ventanas con bordes y botón de ayuda a la vez.

Crear una subclase de VentanaConBorde: VentanaConBordeYBotonDeAyuda.
Problema: No tenemos una ventana con botón de ayuda y sin borde.

Crear clases para todas las combinaciones posibles de funcionalidades.
Problema: Con este ejemplo tendríamos cuatro clases: Ventana, VentanaConBorde, VentanaConBotonDeAyuda y VentanaConBordeYBotonDeAyuda; con tres funcionalidades tendríamos ocho clases y con cuatro, ¡dieciséis!



Aplicabilidad
Añadir objetos individuales de forma dinámica y transparente
Responsabilidades de un objeto pueden ser retiradas
Cuando la extensión mediante la herencia no es viable
Hay una necesidad de extender la funcionalidad de una clase, pero no hay razones para extenderlo a través de la herencia.
Hay la necesidad de extender dinámicamente la funcionalidad de un objeto y quizás quitar la funcionalidad extendida.
Implementación [editar]El patrón Decorator soluciona este problema de una manera mucho más sencilla y extensible.

Se crea a partir de Ventana la subclase abstracta VentanaDecorator y, heredando de ella, BordeDecorator y BotonDeAyudaDecorator. VentanaDecorator encapsula el comportamiento de Ventana y utiliza composición recursiva para que sea posible añadir tantas "capas" de Decorators como se desee. Podemos crear tantos Decorators como queramos heredando de VentanaDecorator.




Decorator (patrón de diseño) - Wikipedia, la enciclopedia libre

Abstract Factory (patrón de diseño)

Abstract Factory (Fábrica Abstracta) es un patrón de diseño para el desarrollo de software.


Contexto y problema Contexto: Debemos crear diferentes objetos, todos pertenecientes a la misma familia. Por ejemplo: las librerías para crear interfaces gráficas suelen utilizar este patrón y cada familia sería un sistema operativo distinto. Así pues, el usuario declara un Botón, pero de forma más interna lo que está creando es un BotónWindows o un BotónLinux, por ejemplo.

El problema que intenta solucionar este patrón es el de crear diferentes familias de objetos.

El patrón Abstract Factory está aconsejado cuando se prevé la inclusión de nuevas familias de productos, pero puede resultar contraproducente cuando se añaden nuevos productos o cambian los existentes, puesto que afectaría a todas las familias creadas.

Aspecto estático

La estructura típica del patrón Abstract Factory es la siguiente:

Cliente: La clase que llamará a la factoría adecuada ya que necesita crear uno de los objetos que provee la factoría, es decir, Cliente lo que quiere es obtener una instancia de alguno de los productos (ProductoA, ProductoB).
AbstractFactory: Es de definición de la interfaces de las factorías. Debe de proveer un método para la obtención de cada objeto que pueda crear. ("crearProductoA()" y "crearProductoB()")
Factorías Concretas: Estas son las diferentes familias de productos. Provee de la instancia concreta de la que se encarga de crear. De esta forma podemos tener una factoría que cree los elementos gráficos para Windows y otra que los cree para Linux, pudiendo poner fácilmente (creando una nueva) otra que los cree para MacOS, por ejemplo.
Producto abstracto: Definición de las interfaces para la familia de productos genéricos. En el diagrama son "ProductoA" y "ProductoB". En un ejemplo de interfaces gráficas podrían ser todos los elementos: Botón, Ventana, Cuadro de Texto, Combo... El cliente trabajará directamente sobre esta interfaz, que será implementada por los diferentes productos concretos.
Producto concreto: Implementación de los diferentes productos. Podría ser por ejemplo "BotónWindows" y "BotónLinux". Como ambos implementan "Botón" el cliente no sabrá si está en Windows o Linux, puesto que trabajará directamente sobre la superclase o interfaz.
Un ejemplo [editar]Veremos un ejemplo didáctico y basado en el libro Head First Design Patterns, de O'Reilly.

Supongamos que disponemos de una cadena de pizzerías. Para crear pizzas disponemos de un método abstracto en la clase Pizzería que será implementada por cada subclase de Pizzería.

abstract Pizza crearPizza()
Concretamente se creará una clase PizzeríaZona por cada zona, por ejemplo la Pizzería de New York sería PizzeriaNewYork y la de Californía PizzeríaCalifornia que implementarán el método con los ingredientes de sus zonas.

Las pizzas son diferentes según las zonas. No es igual la pizza de New York que la pizza de California. Igualmente, aunque usarán los mismos ingredientes (tomate, mozzarella...) no los obtendrán del mismo lugar, cada zona los comprará donde lo tenga más cerca. Así pues podemos crear un método creador de Pizza que sea

Pizza(FactoriaIngredientes fi);
Como vemos utilizamos la factoría abstracta (no las concretas de cada zona, como podría ser IngredientesNewYork o IngredientesCalifornia). Pizza podrá obtener los ingredientes de la factoría independientemente de donde sea. Sería fácil crear nuevas factorías y añadirlas al sistema para crear pizzas con estos nuevos ingredientes. Efectivamente, en este ejemplo cliente es Pizza y es independiente de la Factoría usada.

El creador de la Pizza será el encargado de instanciar la factoría concreta, así pues los encargados de instanciar las factorías concretas serán las pizzerías locales. En PizzeríaNewYork podemos tener el método crearPizza() que realice el siguiente trabajo:

Pizza crearPizza() {
FactoríaIngredientes fi = new IngredientesNewYork();
Pizza pizza = new Pizza(fi); // Uso de la factoría
pizza.cortar();
pizza.empaquetar();
return pizza;
}
Como conclusión podemos observar que gracias a la factoría de ingredientes crear una nueva zona, por ejemplo una pizzería en Barcelona, no nos implicaría estar modificando el código existente, solo deberemos extenderlo (uno de los pilares de la Ingeniería del software) ya crearíamos la subclase de Pizzería: PizzeríaBarcelona que al instanciar la factoría solo debería escoger la factoría de Barcelona. Obviamente se debería crear la factoría de Barcelona que se encargaría de crear los productos obtenidos de Barcelona. Así que en ningún momento modificamos las pizzerías existentes, la superclase pizzería o las otras factorías o productos, solo creamos nuevas clases.

Abstract Factory (patrón de diseño) - Wikipedia, la enciclopedia libre

Composite (patrón de diseño)

El patrón Composite sirve para construir objetos complejos a partir de otros más simples y similares entre sí, gracias a la composición recursiva y a una estructura en forma de árbol.

Esto simplifica el tratamiento de los objetos creados, ya que al poseer todos ellos una interfaz común, se tratan todos de la misma manera.



Problema que soluciona
Imaginemos que necesitamos crear una serie de clases para guardar información acerca de una serie de figuras que serán círculos, cuadrados y triángulos. Además necesitamos poder tratar también grupos de imágenes porque nuestro programa permite seleccionar varias de estas figuras a la vez para moverlas por la pantalla.

En principio tenemos las clases Círculo, Cuadrado y Triángulo, que heredarán de una clase padre que podríamos llamar Figura e implementarán todas la operación pintar(). En cuanto a los grupos de Figuras podríamos caer en la tentación de crear una clase particular separada de las anteriores llamada GrupoDeImágenes, también con un método pintar().

Problema.

Esta idea de separar en clases privadas componentes (figuras) y contenedores (grupos) tiene el problema de que, para cada uno de los dos atributos, el método pintar() tendrá una implementación diferente, aumentando la complejidad del sistema.

Implementación
El patrón Composite da una solución elegante a este problema, de la que además resulta en una implementación más sencilla.

A la clase Figura la llamaríamos Gráfico y de ella extenderían tanto Círculo, Cuadrado y Triángulo, como GrupoDeImágenes. Además, ésta última tendría una relación todo-parte de multiplicidad * con Gráfico: un GrupoDeImágenes contendría varios Gráficos, ya fuesen éstos Cuadrados, Triángulos, u otras clases GrupoDeImágenes.

Así, es posible definir a un grupo de imágenes recursivamente. Por ejemplo, un objeto cuya clase es GrupoDeImágenes podría contener un Cuadrado, un Triángulo y otro GrupoDeImágenes, este grupo de imágenes podría contener un Círculo y un Cuadrado. Posteriormente, a este último grupo se le podría añadir otro GrupoDeImágenes, generando una estructura de composición recursiva en árbol, por medio de muy poca codificación y un diagrama sencillo y claro.

Diagrama


Composite (patrón de diseño) - Wikipedia, la enciclopedia libre

Adapter (patrón de diseño)



Adapter (patrón de diseño)

El patrón Adapter (Adaptador) se utiliza para transformar una interfaz en otra, de tal modo que una clase que no pudiera utilizar la primera, haga uso de ella a través de la segunda.



Propósito
Convierte la interfaz de una clase en otra interfaz que el cliente espera. Adapter permite a las clases trabajar juntas, lo que de otra manera no podrían hacerlo debido a sus interfaces incompatibles.

También conocido como Wrapper (Envoltorio)

Aplicabilidad
usar el patrón Adapter cuando:

Se desea usar una clase existente, y su interfaz no se iguala con la necesitada.
Cuando se desea crear una clase reusable que coopera con clases no relacionadas, es decir, las clases no tienen necesariamente interfaces compatibles.

Estructura
Una clase adaptadora usa múltiples herencias para adoptar una interfaz a otra.





Un objeto adaptador cuenta con la composición de objetos.



Participantes
Target define la interfaz específica del dominio que Client usa.
Client colabora con la conformación de objetos para la interfaz Target.
Adaptee define una interfaz existente que necesita adaptarse
Adapter adapta la interfaz de Adaptee a la interfaz Target

Colaboraciones
Client llama a las operaciones sobre una instancia Adapter. De hecho, el adaptador llama a las operaciones de Adaptee que llevan a cabo el pedido.

Consecuencias
los adaptadores de clase y objetos tienen diferentes trade-off

Un adaptador de clase:
Adapta Adaptee a Target encargando a una clase Adaptee concreta. Como consecuencia, una clase adaptadora no funcionará cuando se desea adaptar una clase y todas sus subclases.
Permite a los Adapter sobrescribir algo de comportamiento de Adaptee, ya que Adapter es una subclase de Adaptee.
Un adaptador de objeto:
Permite que un único Adapter trabaje con muchos Adaptees, es decir, el Adapter por sí mismo y las subclases (si es que la tiene). El Adapter también puede agregar funcionalidad a todos los Adaptees de una sola vez.
Hace difícil sobrescribir el comportamiento de Adaptee. Esto requerirá derivar Adaptee y hacer que Adapter se refiera a la subclase en lugar que al Adaptee por sí mismo.
Aquí hay otras cuestiones a considerar cuando se utiliza el patrón Adapter:

1.¿Cuanta adaptación hace el Adapter? Adapter varía en la cantidad de trabajo que hace para adaptar Adaptee a la interfaz Target. Hay un espectro de trabajo posible, desde una simple conversión (por ejemplo, cambiando los nombres de las operaciones) hasta soportando un conjunto de operaciones enteramente diferentes. La cantidad de trabajo que Adapter hace depende de cuanto de similar tienen la interfaz Target con Adaptee.
2.Adaptadores Pluggables Una clase es más reusable cuando minimizás la suposición que otras clases deben hacer para utilizarla. Mediante la construcción en una clase de la adaptación de una interfaz, eliminas la suposición de que otras clases ven la misma interfaz. Puesto de otra manera, la adaptación de la interfaz nos permite incorporar nuesta clase en sistemas existentes que pueden esperar diferentes interfaces para la clase.
Implementación [editar]Crear una nueva clase que será el Adaptador, que extienda del componente existente e implemente la interfaz obligatoria. De este modo tenemos la funcionalidad que queríamos y cumplimos la condición de implementar la interfaz.

La diferencia entre los patrones Adapter y Facade, es que el primero reutiliza una interfaz ya existente, mientras que el segundo define una nueva con el objetivo de simplificarla.

Adapter (patrón de diseño) - Wikipedia, la enciclopedia libre

Facade (patrón de diseño)

Facade (patrón de diseño)

Facade, façade o fachada es un patrón de diseño que sirve para proveer de una interfaz unificada sencilla que haga de intermediaria entre un cliente y una interfaz o grupo de interfaces más complejas.

Facade puede hacer una biblioteca de software más fácil de usar y entender, ya que facade implementa métodos convenientes para tareas comunes; hacer el código que usa la biblioteca más legible, por la misma razón; puede reducir la dependencia de código externo en los trabajos internos de una biblioteca, ya que la mayoría del código lo usa Facade, permitiendo así más flexibilidad en el desarrollo de sistemas; y puede envolver una colección mal diseñada de APIs con un solo API bien diseñado.



Problemas que soluciona
Problema: Un cliente necesita acceder a parte de la funcionalidad de un sistema más complejo.

Definir una interfaz que permita acceder solamente a esa funcionalidad.
Problema: Existen grupos de tareas muy frecuentes para las que se puede crear código más sencillo y legible.

Definir funcionalidad que agrupe estas tareas en funciones o métodos sencillos y claros.
Problema: Una biblioteca es difícilmente legible.

Crear un intermediario más legible.
Problema: Dependencia entre el código del cliente y la parte interna de una biblioteca.

Crear un intermediario y realizar llamadas a la biblioteca sólo o, sobre todo, a través de él.
Problema: Necesidad de acceder a un conjunto de APIs, que pueden, además, tener un diseño no muy bueno.

Crear una API intermedia, bien diseñada, que permita acceder a la funcionalidad de las demás.
Cuidado: Facade debe utilizarse para crear clases sencillas, no clases que "sirvan para todo" o "lo hagan todo".



Facade (patrón de diseño) - Wikipedia, la enciclopedia libre

Factory Method (patrón de diseño)

Factory Method (patrón de diseño)

En diseño de software, el patrón de diseño Factory Method consiste en utilizar una clase constructora (al estilo del Abstract Factory) abstracta con unos cuantos métodos definidos y otro(s) abstracto(s): el dedicado a la construcción de objetos de un subtipo de un tipo determinado. Es una simplificación del Abstract Factory, en la que la clase abstracta tiene métodos concretos que usan algunos de los abstractos; según usemos una u otra hija de esta clase abstracta, tendremos uno u otro comportamiento.

Estructura
Las clases principales en este patrón son el creador y el producto. El creador necesita crear instancias de productos, pero el tipo concreto de producto no debe ser forzado en las subclases del creador, porque entonces las posibles subclases del creador deben poder especificar subclases del producto para utilizar.




La solución para esto es hacer un método abstracto (el método de la fábrica) que se define en el creador. Este método abstracto se define para que devuelva un producto. Las subclases del creador pueden sobrescribir este método para devolver subclases apropiadas del producto...

http://geeks.ms/blogs/lontivero/archive/2008/07/31/patterns-factory-method-explicado.aspx
Factory Method (patrón de diseño) - Wikipedia, la enciclopedia libre

Builder (patrón de diseño)

Como Patrón de diseño, el patrón builder (Constructor) es usado para permitir la creación de una variedad de objetos complejos desde un objeto fuente (Producto), el objeto fuente se compone de una variedad de partes que contribuyen individualmente a la creación de cada objeto complejo a través de un conjunto de llamadas a interfaces comunes de la clase Abstract Builder.

A menudo, el patrón builder construye el patrón Composite, un patrón estructural.

Intención: Abstrae el proceso de creación de un objeto complejo, centralizando dicho proceso en un único punto, de tal forma que el mismo proceso de construcción pueda crear representaciones diferentes.



Diagrama de Clases

Builder
interfaz abstracta para crear productos.
Concrete Builder
implementación del Builder
construye y reúne las partes necesarias para construir los productos
Director
construye un objeto usando el patrón Builder
Producto
El objeto complejo bajo construcción

Ventajas

Reduce el acoplamiento.
• Permite variar la representación interna de estructuras compleja, respetando la interfaz común de la clase Builder.
• Se independiza el código de construcción de la representación. Las clases concretas que tratan las representaciones internas no forman parte de la interfaz del Builder.
• Cada ConcreteBuilder tiene el código especifico para crear y modificar una estructura interna concreta.
• Distintos Director con distintas utilidades (visores, parsers, etc) pueden utilizar el mismo ConcreteBuilder.
• Permita un mayor control en el proceso de creación del objeto. El Director controla la creación paso a paso, solo cuando el Builder ha terminado de construir el objeto lo recupera el Director.






Builder (patrón de diseño) - Wikipedia, la enciclopedia libre

martes, 27 de abril de 2010

Patrones de Diseño: State vs Strategy

Lo que es diferente es la intención de lo que se hace. El esquema puede ser igual, pero su sentido es bastante distinto.

Se usan estados cuando el comportamiento de un objeto depende de algún modo de su situación, cuando su comportamiento varía de una situación a otra. Imagina un horno microondas (con teclas). El comportamiento de la tecla de encendido depende de que antes hayas pulsado ya un tiempo y una temperatura. Si estás en el estado inicial, pulsar encendido no hará nada. Si estás en el estado de ya haber introducido tiempo y potencia, entonces el mismo botón encenderá el horno. El comportamiento del teclado depende de su estado.

Se usan Estrategias cuando puedes tener diferentes comportamientos para objetos que por lo demás son iguales. Imagina un horno de nuevo (pero ahora un horno cualquiera). Todos los hornos tienen un botón de encendido, pero en uno de ellos el botón de encender lo que hace es abrir el gas, en otro lo que hace es conectar la corriente a la resistencia, en otro activar el generador de microondas, en otro más antiguo pone a frotar dos palitos (xD)...
Todos los objetos horno son más o menos equivalentes, todos calientan lo que haya dentro, pero la forma de hacerlo (con gas, con electricidad, con microondas, con un frotador de palitos (xD)) es diferente.

En ambos casos lo que se persigue es encapsular el comportamiento e independizarlo del objeto. Pero en cada caso lo haces por diferentes razones. En el caso del estado porque ese comportamiento puede ir variando y en el caso de la estrategia porque podrías reutilizar el objeto genérico simplemente aplicándole otro comportamiento.

En un caso irás asignando diferentes estado con diferentes comportamientos a lo largo del tiempo. En el otro asignarás una u otra estrategia al inicializar el objeto y luego (probablemente) ya no más.



Luego hay otras diferencias menores, como que las estrategias en general tienden a ser independientes entre sí. "ActivarMicroondas" no tiene ninguna relación con "AbrirGas". Los estados en general tienden a ser bastante dependientes. El estado "TiempoAceptado" y "PotenciaAceptada" suelen compartir variables de estado (precisamente) y se conocen. Hay una relación que dice que si estoy en "TiempoAceptado" e introduzco la potencia, iré a "PotenciaAceptada".


Patrones de Diseño: State vs Strategy - Foros del Web

lunes, 26 de abril de 2010

Resumen Strategy


El patrón strategy (estrategia) esta orientado a resolver situaciones en las que nos encontramos con un problema base pero existen diversas estrategias para abordar el problema. En este sentido nuestro problema define un interface que será (o podrá ser) implementado de diversas formas.


Resumen Template Method




template method define una superclase que sirve como plantilla de metodos a su subclases

http://www.dofactory.com/Patterns/PatternTemplate.aspx

Resumen Double Dispatch