Your ebook has decrypted.
The TXT file just save 20% of ebook content.
Please register the software, then get all contents and the valid
ebook format.
Title : Python. Patrones de diseño - Guía de aprendizaje
(Spanish Edition)
Author: Córcoles, Sheila,Moreno, Alfredo
El contenido de la obra ha sido desarrollado exclusivamente por los
miembros del equipo de Software Developer Coach.
[image "A picture containing text, clipart Description automatically
generated" file=image_rsrc2F6.jpg] Reservados todos los derechos.
Queda rigurosamente prohibida, sin la autorización escrita de
Software Developer Coach, bajo las sanciones establecidas en las
leyes, la reproducción parcial o total de esta obra por cualquier
medio o procedimiento, incluidos la reprografía y el tratamiento
informático, así como la distribución de ejemplares mediante alquiler
o préstamo público.
Primera edición
Para más información visita:
www.softwaredeveloper.coach
Tabla de contenido
INTRODUCCIÓN
PATRONES DE DISEÑO
¿Qué son?
¿Por qué utilizarlos?
Tipos de patrones
PATRONES DE DISEÑO CREACIONALES
Patrón de diseño Singleton
Patrón de diseño Prototype
Patrón de diseño Builder
Patrón de diseño Factory Method
Patrón de diseño Abstract Factory
PATRONES DE DISEÑO ESTRUCTURALES
Patrón de diseño Adapter
Patrón de diseño Bridge
Patrón de diseño Composite
Patrón de diseño Decorator
Patrón de diseño Facade
Patrón de diseño Flyweight
Patrón de diseño Proxy
PATRONES DE DISEÑO DE COMPORTAMIENTO
Patrón de diseño Chain of Responsibility
Patrón de diseño Command
Patrón de diseño Interpreter
Patrón de diseño Iterator
Patrón de diseño Mediator
Patrón de diseño Memento
Patrón de diseño Observer
Patrón de diseño State
Patrón de diseño Strategy
Patrón de diseño Template Method
Patrón de diseño Visitor
SOBRE LOS AUTORES Y AGRADECIMIENTOS
MATERIAL DESCARGABLE
OTROS LIBROS DE LOS AUTORES
INTRODUCCIÓN
¡Bienvenido al libro de patrones de diseño en Python!
En este libro vamos a realizar un viaje total a través del mundo de
los patrones de diseño, y además, lo vamos a hacer, utilizando
nuestro lenguaje de programación favorito: Python.
Los patrones de diseño son como recetas de cocina que los
programadores utilizamos para resolver problemas repetitivos con
los que nos encontramos mientras programamos.
A lo largo del libro exploraremos los conceptos básicos de cada uno
de los patrones de diseño y realizaremos un ejemplo práctico en
Python de cómo se implementa. Hemos incluido los patrones de
diseño más conocidos: Singleton, Factory Method, Abstract Factory,
Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy,
Chain of Responsibility, Command, Interpreter, Iterator, Mediator,
Memento, Observer, State, Strategy, Template Method y Visitor.
Este libro es ideal tanto si ya tienes mucha experiencia como
programador como si estás empezando a aprender patrones de
diseño. Si buscas una guía completa, que incluya todos los patrones
de diseño, este libro es justo lo que necesitas.
El libro está dividido en cuatro capítulos. En el primero vamos a
explicarte una introducción a qué son los patrones de diseño. En los
tres siguientes capítulos vamos a explicarte los diferentes tipos de
patrones de diseño existentes: patrones de diseño creacionales,
patrones de diseño estructurales y patrones de diseño de
comportamiento.
¡¡EMPECEMOS!!
PATRONES DE DISEÑO
En este capítulo vamos a explicarte toda la teoría sobre los patrones
de diseño, qué son, por qué utilizarlos y qué tipos hay.
¿Qué son?
¿Sabías que los patrones de diseño son como trucos o recetas en el
mundo de la programación? Los patrones de diseño son soluciones
ya existentes a problemas comunes que te encuentras cuando estás
programando. Estos trucos o recetas nos dan un camino marcado y
probado para solucionar estos problemas, lo que nos permite
solucionarlos de una manera rápida y eficaz.
Los patrones de diseño son muy populares cuando trabajamos con
programación orientada a objetos. Los patrones nos ayudan a
reutilizar código que ya hemos escrito, a hacer que nuestros
programas puedan crecer sin problemas y a poder mantenerlos
fácilmente. Usar patrones de diseño es como tener una caja de
herramientas llena de soluciones listas para usar. Esto nos ahorra
mucho tiempo y esfuerzo, porque no tenemos que inventar una
solución nueva cada vez que nos enfrentamos a un problema que ya
hemos visto antes.
Hay muchos tipos de patrones de diseño: los patrones de creación,
que nos ayudan a crear objetos; los patrones estructurales, que nos
ayudan a organizar y relacionar objetos; y los patrones de
comportamiento, que nos ayudan a controlar cómo interactúan los
objetos. Cada tipo de patrón resuelve un problema específico, y son
como plantillas que podemos adaptar a nuestras necesidades.
¿Por qué utilizarlos?
Tal y como te hemos explicado antes, los patrones de diseño nos
ayudan a resolver problemas comunes que nos encontramos
mientras programamos. Los patrones puedes utilizarlos con total
independencia del lenguaje de programación que estés utilizando,
pero en este libro nos hemos centrado en utilizarlos con Python.
A continuación vamos a explicarte las principales razones por las que
tienes que utilizar patrones de diseño en tus desarrollos de software:
Mejoran la eficiencia de tu código: al utilizar patrones de diseño vas
a asegurarte de que tu código sea más eficiente, organizado y fácil
de mantener. Esto se debe a que los patrones establecen una que
puedes seguir una y otra vez en diferentes proyectos.
Te ayudan a resolver problemas más fácilmente: al utilizar patrones
de diseño puedes ahorrar tiempo y esfuerzo en la resolución de
problemas, lo que significa que puedes concentrarte más en añadir
nuevas funcionalidades y mejoras a tu software.
Mejoran la calidad del programa: si utilizas patrones de diseño
puedes estar seguro de que tu programa será más fiable, capaz de
crecer sin problemas y fácil de mantener.
Hacen que tu código sea más fácil de entender para otros
programadores: Al utilizar patrones de diseño, haces que tu código
sea más fácil de entender por otros programadores y que puedan
hacer cambios sin problemas. Esto es súper importante cuando estás
trabajando en proyectos con un equipo o en proyectos en los que
varios desarrolladores deben trabajar juntos.
Tipos de patrones
Como hemos visto anteriormente, los patrones de diseño son
soluciones que puedes volver a usar cada vez que te encuentres con
esos problemas que siempre pueden aparecer cuando estás
programando.
Los patrones más importantes están agrupados de la siguiente
forma:
Patrones de creación: estos patrones tienen que ver con cómo
creamos objetos. Nos dan soluciones para crear objetos que son un
poco complicados.
Patrones de estructura: estos patrones nos ayudan a organizar
nuestros objetos y a cómo se relacionan entre si. Nos dan soluciones
para organizar y combinar objetos de una manera que tenga
sentido.
Patrones de comportamiento: estos patrones se centran en cómo
interactúan nuestros objetos. Nos dan soluciones para hacer que
nuestros objetos se comuniquen de una forma eficiente.
Estos son solo algunos ejemplos de los tipos de patrones de diseño
que existen. Recuerda que los patrones de diseño no son una varita
mágica que soluciona todos los problemas que nos encontramos
cuando programamos, son más bien como herramientas en nuestra
caja de herramientas de programación, que nos proporcionan una
forma probada de resolver un problema en particular.
PATRONES DE DISEÑO CREACIONALES
Los patrones de diseño creacionales son aquellos que se enfocan en
la forma en que los objetos se crean. Nos dan un enfoque
organizado para gestionar la creación de objetos y nos ayudan a
evitar errores y seguir buenas prácticas de programación.
Entre los patrones de diseño creacionales más comunes se
encuentran:
Singleton: este patrón garantiza que una clase sólo tenga una
instancia en todo momento, y proporciona un punto de acceso
global a ella.
Prototype: este patrón permite crear nuevos objetos a partir de un
objeto existente, en lugar de crear uno completamente nuevo. Se
hace una copia del objeto existente y se modifica según sea
necesario.
Builder: este patrón permite crear objetos complejos a partir de una
serie de pasos y partes. Se utiliza un objeto constructor para ir
construyendo el objeto paso a paso hasta que está completamente
construido.
Factory Method: este patrón permite crear objetos sin especificar la
clase exacta que se creará. En su lugar, se especifica una interfaz
común que deberán implementar todas las clases que se quieran
crear.
Abstract Factory: este patrón permite crear familias de objetos
relacionados sin especificar las clases concretas que se crearán. Se
proporciona una interfaz para crear objetos, y luego se utiliza una
clase concreta que implementa esta interfaz para crear objetos
específicos.
Patrón de diseño Singleton
En este apartado vamos a explicar el patrón Singleton, junto con las
ventajas e inconvenientes de utilizarlo, su estructura y un ejemplo
de utilización.
DescripciónEl patrón de diseño Singleton es un patrón creacional
que asegura que una clase solo tenga una única instancia, y
además, proporciona un punto de acceso global a esta única
instancia. Esta clase se encarga de crear su propia instancia la
primera vez que se accede a ella, y luego cualquier llamada posterior
a la clase utilizará esta única instancia.
En otras palabras: queremos que pienses en la llave de tu casa. No
importa las veces que quieras entrar a tu casa, siempre vas a utilizar
la misma llave para entrar. Pues ese es el concepto, no utilizas una
llave cada vez que quieres entrar, utilizas siempre la misma llave.
Llevándolo a programación: imagina que tienes una clase, el patrón
Singleton te asegura que sólo se instanciará una única clase, y se
hará la primera vez que la necesites. Las siguientes veces que
necesites utilizar la clase, el patrón Singleton te garantizará que
utilizas la primera instancia que se creó en lugar de crear una nueva
instancia cada vez.
Singleton es útil cuando necesitas tener una única "fuente de
verdad" en tu código. Por ejemplo, si tienes un conjunto de
configuraciones o recursos que todo tu programa necesita usar,
Singleton se asegura de que solo hay una copia de ellos y todos en
el programa la comparten.
La implementación de Singleton requiere un control de acceso
restringido al constructor junto con un método de clase para acceder
a la única instancia de la clase.
Ventajas e inconvenientesA continuación te explicamos las ventajas
que tiene utilizar el patrón Singleton:
Control de acceso: te permite tener un control total sobre la creación
de objetos, lo que es muy útil para aplicaciones que requieren una
única instancia de una clase.
Mejora la eficiencia: al tener una única instancia de una clase, se
evita la creación de objetos innecesarios, lo que mejora la eficiencia
de la aplicación.
Fácil de entender: es un patrón de diseño sencillo de implementar y
comprender.
Código más limpio: al tener una única clase que se encarga de la
creación de objetos, se mejora la legibilidad del código y se evita la
duplicación de código.
La utilización del patrón Singleton tiene los siguientes
inconvenientes:
Difícil de probar: es difícil de probar ya que no puedes crear nuevas
instancias para probar y por tanto puede ser más difícil verificar que
todo funciona correctamente.
Puede complicarse en el futuro: si en el futuro necesitas que tu clase
haga cosas diferentes en diferentes casos, Singleton puede
complicarte un poco la vida.
Difícil de escalar: al tener una única instancia de una clase, puede
ser difícil de escalar la aplicación.
DiagramaA continuación te mostramos el diagrama de clases del
patrón Singleton:
[image "Graphical user interface, application Description
automatically generated" file=image_rsrc2F7.jpg] La clase Singleton
declara un método estático y público (obtenerInstancia) que
devuelve la misma instancia que la clase. El constructor de la clase
Singleton tiene que ser privado para que no pueda ser utilizado, ya
que la única forma de obtener un objeto de la clase Singleton es a
través del método obtenerInstancia.
ImplementaciónA continuación te mostramos un ejemplo de código
fuente de implementación del patrón Singleton:
class Singleton:
__instance = None
@staticmethod
def getInstance():
Función que permite acceder
a la instancia única de la clase
if Singleton.__instance == None:
Singleton()
return Singleton.__instance
def init(self):
El constructor es privado para
asegurarnos de que sólo se
puede crear una instancia
if Singleton.__instance != None:
raise Exception("Esta clase es un singleton, no se pueden crear más
de una instancia.")
else:
Singleton.__instance = self
Creamos dos instancias de la
clase Singleton
singleton1 = Singleton.getInstance()
singleton2 = Singleton.getInstance()
Comprobamos si ambas
instancias son la misma
print(singleton1 is singleton2)
Como se puede ver en el ejemplo, la clase Singleton sólo permite
crear una única instancia y todas las llamadas subsiguientes a la
función getInstance devuelven la misma instancia. En el ejemplo se
crean dos objetos y después se comparan si son iguales.
La ejecución del ejemplo tiene la siguiente salida:
[image file=image_rsrc2F8.jpg] Patrón de diseño Prototype
En este apartado vamos a explicar el patrón Prototype, junto con las
ventajas e inconvenientes de utilizarlo, su estructura y un ejemplo
de utilización.
DescripciónEl patrón de diseño Prototype es un patrón creacional
que permite crear nuevos objetos a partir de un objeto original,
conocido como prototipo. En lugar de crear un objeto desde cero, el
patrón Prototype clona el objeto existente y luego lo modifica según
sea necesario.
En otras palabras: imagina que estás haciendo un dibujo muy
complejo y que lleva mucho tiempo hacerlo. Un día te das cuenta de
que necesitas hacer un dibujo casi igual pero con algunos cambios.
¿Qué es más fácil: hacerlo de cero o hacer una copia y hacer los
cambios? Estamos seguro que dices la segunda opción. Pues eso es
justamente lo que hace el patrón Prototype, en lugar de hacer todo
desde cero cada vez, toma un objeto existente y lo duplica (clona).
Esto es especialmente útil cuando estás trabajando con algo que
lleva mucho tiempo o esfuerzo crear. En lugar de pasar por todo el
proceso de crearlo de nuevo, simplemente clonas lo que ya tienes y
haces los cambios necesarios. Es como tener una plantilla que
puedes reutilizar una y otra vez. Además, es muy útil también
cuando necesitas crear algo que es similar a algo que ya existe, pero
con algunas diferencias. En lugar de crear algo desde cero,
simplemente tomas el objeto existente, haces una copia y luego
ajustas la copia a tus necesidades.
En pocas palabras, el patrón Prototype te permite hacer "copias
personalizadas" de los objetos de una manera más eficiente y
práctica.
Ventajas e inconvenientesA continuación te explicamos las ventajas
que tiene utilizar el patrón Prototype:
Mejora la velocidad y la eficiencia: puedes crear objetos nuevos a
partir de objetos existentes, sin tener que hacerlo desde cero. Como
no estás haciendo todo desde cero, puedes trabajar más rápido y de
manera más eficiente.
Fácil de manejar: te permite la creación de objetos complejos de
una manera más fácil y organizada, haciendo tu vida mucho más
fácil.
Creación de objetos personalizables: te permite la creación de
objetos personalizados según las necesidades específicas de tu
aplicación, justo como las necesites.
La utilización del patrón Prototype tiene los siguientes
inconvenientes:
Consumo de memoria: tienes que asegurarte de liberar la memoria
de los objetos clonados que ya no necesites, si no lo haces podrías
tener problemas.
Dificultad de mantenimiento: si no implementas el patrón de forma
correcta puedes encontrarte con problemas de mantenimiento.
Falta de flexibilidad: los objetos clonados no siempre pueden ser
modificados de forma independiente.
Puede ser difícil de escalar: si no tienes en cuenta cómo podría
crecer tu aplicación, podrías tener problemas de escalabilidad en el
futuro.
DiagramaA continuación te mostramos el diagrama de clases del
patrón Prototype:
[image file=image_rsrc2F9.jpg] El patrón Prototype está compuesto
por los siguientes elementos:
Prototipo: es la interfaz común que define el método de clonación
que permite crear una copia exacta del objeto original. El prototipo
es una clase abstracta o una interfaz que define el comportamiento
para la clonación de objetos.
PrototipoConcreto: es la clase concreta que implementa la interfaz
del prototipo y proporciona la implementación real del método de
clonación. El objeto de esta clase se utiliza como el objeto original
para crear copias.
En resumen, el patrón Prototype está compuesto por una interfaz
común para la clonación de objetos, una clase concreta que
implementa la interfaz, un cliente que utiliza el prototipo para crear
copias y un objeto clonado que es la copia exacta del objeto original.
ImplementaciónA continuación te mostramos un ejemplo de código
fuente de implementación del patrón Prototype:
import copy
class Prototype:
def clone(self):
return copy.deepcopy(self)
class ConcretePrototype(Prototype):
def init(self, name, value):
self.name = name
self.value = value
def str(self):
return f"{self.name}: {self.value}"
Creamos una instancia del
prototipo concreto
prototype = ConcretePrototype("Prototipo 1", 1)
Clonamos el prototipo
clone = prototype.clone()
Cambiamos el valor del clone
clone.value = 2
Mostramos los valores de
ambos prototipos
print(prototype)
print(clone)
Hemos definido una clase base Prototype que proporciona un
método clone que se puede utilizar para clonar objetos. La clase
ConcretePrototype es una subclase de Prototype y agrega una
implementación concreta de los objetos que se pueden clonar.
El código crea una instancia del prototipo concreto y luego clona el
objeto. Después, se modifica el valor del objeto clonado y se
muestran los valores de ambos objetos, lo que demuestra que son
objetos diferentes a pesar de ser una copia del mismo prototipo
original.
La ejecución del ejemplo tiene la siguiente salida:
[image "A picture containing text Description automatically
generated" file=image_rsrc2FA.jpg] Patrón de diseño Builder
En este apartado vamos a explicar el patrón Builder, junto con las
ventajas e inconvenientes de utilizarlo, su estructura y un ejemplo
de utilización.
DescripciónEl patrón de diseño Builder es un patrón de creación que
te ayuda a construir objetos complejos paso a paso, sin tener que
manejar todos los detalles de la creación a la vez. Es decir, divide la
construcción en partes para que puedas manejarla fácilmente.
En otras palabras: el patrón Builder es como un director de música.
El director tiene la obra en su cabeza, pero necesita a los diferentes
músicos que participarán en la obra para poderla tocar. Es decir, por
un lado tendrá los músicos de los instrumentos de cuerda, por otro
los de viento, por otro los de percusión, etc. Cada uno de ellos tiene
su área de especialización y sabe cómo hacer su parte de la obra. El
resultado final será una obra de música en la que todos los músicos
han hecho su trabajo siguiendo las instrucciones del director.
Ventajas e inconvenientesA continuación te explicamos las ventajas
que tiene utilizar el patrón Builder:
Permite crear objetos complejos paso a paso: esto es muy útil
cuando los objetos tienen múltiples configuraciones posibles o
cuando estas configuraciones son difíciles de manejar o cambian
mucho.
Separación de responsabilidades: cada parte del código tiene su
tarea específica. De esta forma, la construcción del objeto se
mantiene separada de cómo se representa. Esto ayuda a que tu
código sea más organizado y más fácil de mantener, porque cada
parte sabe lo que tiene que hacer y no se mete en lo que no le toca.
Flexibilidad: te permite tener diferentes "constructores" para
producir objetos con distintas características y comportamientos.
La utilización del patrón Builder tiene los siguientes inconvenientes:
Aumento de la complejidad: puede hacer que tu código sea más
complejo y necesites más clases para construir el objeto.
Pérdida de eficiencia: como estás creando el objeto paso a paso,
puede que necesites más código y más objetos para crear el objeto
final. Esto puede afectar un poco el rendimiento de tu programa.
Aumento de la cantidad de código: es muy probable que necesites
crear más clases, lo que puede hacer que tengas más código para
mantener a largo plazo.
DiagramaA continuación te mostramos el diagrama de clases del
patrón Builder:
[image "A picture containing timeline Description automatically
generated" file=image_rsrc2FB.jpg] El patrón Builder está
compuesto por los siguientes elementos:
Producto: clase que representa el objeto complejo que se desea
construir. Si piensas en el ejemplo de la obra de música, el Producto
es la obra de música que se toca.
Builder: interfaz o clase abstracta que define los métodos necesarios
los diferentes Builder que compondrán el patrón. No es un elemento
obligatorio en el patrón, pero es muy recomendable.
Builder Concreto: clase concreta que implementa los métodos
definidos en la interfaz Builder. Cada BuilderConcreto puede construir
el producto de una manera diferente. Si piensas en el ejemplo de la
obra de música, cada BuilderConcreto es cada especialidad de
músicos (cuerda, viento, percusión, etc).
Director: clase que dirige el proceso de construcción utilizando los
diferentes Builders. Si piensas en el ejemplo de la obra de música, el
Director es el director de la obra.
ImplementaciónA continuación te mostramos un ejemplo de código
fuente de implementación del patrón Builder:
Definición de la clase Pizza y
sus atributos
class Pizza:
def init(self):
self.size = ""
self.cheese = False
self.pepperoni = False
self.ham = False
self.mushrooms = False
self.tomatoes = False
self.masa_type = ""
Definición de la clase Builder,
que define los métodos para
construir los objetos Pizza
class PizzaBuilder:
def init(self):
self.pizza = Pizza()
def set_size(self, size):
self.pizza.size = size
def add_cheese(self):
self.pizza.cheese = True
def add_pepperoni(self):
self.pizza.pepperoni = True
def add_ham(self):
self.pizza.ham = True
def add_mushrooms(self):
self.pizza.mushrooms = True
def add_tomatoes(self):
self.pizza.tomatoes = True
def set_masa_type(self, masa_type):
self.pizza.masa_type = masa_type
def get_result(self):
return self.pizza
Definición de un Director que
utiliza el Builder para
construir diferentes tipos de
pizza
class Director:
def init(self, builder):
self._builder = builder
def construct_margarita(self):
self._builder.set_size("12 inches")
self._builder.add_cheese()
self._builder.add_tomatoes()
self._builder.set_masa_type("thin crust")
def construct_pepperoni(self):
self._builder.set_size("16 inches")
self._builder.add_cheese()
self._builder.add_pepperoni()
self._builder.add_mushrooms()
self._builder.set_masa_type("thick crust")
Construcción de pizzas
utilizando el builder
pizza_builder = PizzaBuilder()
director = Director(pizza_builder)
director.construct_margarita()
pizza = pizza_builder.get_result()
print(pizza.dict)
director.construct_pepperoni()
pizza = pizza_builder.get_result()
print(pizza.dict)
En el ejemplo hemos definido la clase Pizza (Producto) y un Builder
que nos permitirá construir objetos de tipo Pizza. La clase Director
será la encargada de construir diferentes tipos de pizzas utilizando el
Builder. El ejemplo construye dos tipos diferentes de pizza y los
muestra por pantalla.
La ejecución del ejemplo tiene la siguiente salida:
[image file=image_rsrc2FC.jpg] Patrón de diseño Factory Method
En este apartado vamos a explicar el patrón Factory Method, junto
con las ventajas e inconvenientes de utilizarlo, su estructura y un
ejemplo de utilización.
DescripciónEl patrón de diseño Factory Method es un patrón
creacional que te permite crear diferentes tipos de objetos sin tener
que saber todos los detalles de cómo se crean.
En otras palabras: el patrón es como una línea de montaje en una
fábrica de coches. Los trabajadores de la línea de montaje no saben
todos los detalles de cómo se ensambla un coche, sólo saben su
parte del proceso de montaje.
El problema que resuelve el patrón Factory Method es que a menudo
necesitamos crear objetos de diferentes tipos, pero no queremos
tener que modificar nuestro código cada vez que se agregue un
nuevo tipo de objeto. El patrón Factory Method nos permite
encapsular la creación de objetos en una clase separada y así
simplificar el código y permitir la extensión del sistema de forma fácil
y sencilla.
Ventajas e inconvenientesA continuación te explicamos las ventajas
que tiene utilizar el patrón Factory Method:
Flexibilidad: ofrece una manera de crear objetos sin necesidad de
especificar la clase exacta que se va a crear.
Mantenimiento sencillo: si necesitas cambiar la forma en que se
crean tus objetos, sólo tienes que modificar la implementación del
método de fábrica. No necesitas tocar todo el código.
Reducción del acoplamiento: al delegar la creación de objetos a una
clase separada, se reduce el acoplamiento entre las clases.
La utilización del patrón Factory Method tiene los siguientes
inconvenientes:
Mayor complejidad: puede agregar complejidad al código y
aumentar el número de clases necesarias para implementar el
patrón.
Sobrecarga en tiempo de ejecución: al delegar la creación de objetos
al Factory Method se puede agregar un poco de sobrecarga en
tiempo de ejecución debido a la necesidad de crear un objeto
adicional, aunque en la mayoría de los casos la sobrecarga es
insignificante.
Difícil de implementar: puede ser difícil de implementar
correctamente si se necesitan múltiples parámetros para crear
objetos. Además, si no se usa correctamente, puede provocar una
jerarquía de clases complicada y difícil de entender.
DiagramaA continuación te mostramos el diagrama de clases del
patrón Factory Method:
[image file=image_rsrc2FD.jpg] El patrón Factory Method está
compuesto por los siguientes elementos:
Producto: interfaz o clase abstracta que define el objeto que se
creará mediante el método de fábrica.
Producto Concreto: implementación concreta de la interfaz o clase
abstracta Producto.
Creador: clase abstracta que declara el método de fábrica abstracto
para crear objetos de Producto. El Creador también puede contener
código compartido que se utiliza para crear objetos de Producto.
Creador Concreto: implementación concreta de la clase abstracta
Creador que proporciona una implementación para el método de
fábrica abstracto. El Creador Concreto utiliza el método de fábrica
para crear objetos de Producto.
ImplementaciónA continuación te mostramos un ejemplo de código
fuente de implementación del patrón Factory Method:
Definición de la clase
abstracta Producto
class Producto:
def descripcion(self):
pass
Definición de la clase concreta
ProductoA que implementa la
interfaz Producto
class ProductoA(Producto):
def descripcion(self):
return "Soy un producto de tipo A"
Definición de la clase concreta
ProductoB que implementa la
interfaz Producto
class ProductoB(Producto):
def descripcion(self):
return "Soy un producto de tipo B"
Definición de la clase
abstracta Creador
class Creador:
def crear_producto(self):
pass
Definición de la clase concreta
CreadorA que implementa la
clase abstracta Creador