PATRONES DE DISEÑO

Documentación

25 DE OCTUBRE DE 2018
PROGRAMACION DE APLICACIONES
GIBRAN ENRIQUE SALAZAR VILLARREAL
 1

Introducción
Los patrones de diseño representan las mejores prácticas utilizadas por
desarrolladores experimentados de software orientados a objetos. Los patrones de
diseño son soluciones a problemas generales que los desarrolladores de software
enfrentaron durante el desarrollo de software. Estas soluciones fueron obtenidas
por prueba y error por numerosos desarrolladores de software durante un período
de tiempo bastante importante.
En este documento se mostrarán cada uno de los patrones de diseño solicitadas,
explicando sus ventajas y desventajas, así como mostrando un ejemplo practica
de cada patrón, y explicando la estructura, implementación y funcionalidad de
cada uno de ellos.
 2

Contenido
Abstract Factory.................................................................................................................................. 3
Factory Method ................................................................................................................................ 10
Singleton ........................................................................................................................................... 15
Prototype .......................................................................................................................................... 19
Builder ............................................................................................................................................... 24
Adapter ............................................................................................................................................. 31
Bridge ................................................................................................................................................ 36
Composite ......................................................................................................................................... 42
Decorator .......................................................................................................................................... 44
Facade ............................................................................................................................................... 49
Flyweight........................................................................................................................................... 54
Proxy ................................................................................................................................................. 58
Chain of responsibility ...................................................................................................................... 62
Command .......................................................................................................................................... 66
Interpreter ........................................................................................................................................ 70
Iterator .............................................................................................................................................. 74
Mediator ........................................................................................................................................... 78
Memento .......................................................................................................................................... 82
Observer............................................................................................................................................ 86
State .................................................................................................................................................. 90
Strategy ............................................................................................................................................. 95
Template method ........................................................................................................................... 100
Visitor .............................................................................................................................................. 104
 3

Abstract Factory
El primer patrón de diseño del que se hablara es el Abstract Factory.

Ventajas:

Aísla las clases de implementación: ayuda a controlar los objetos que se creen y
encapsula la responsabilidad y el proceso de creación de objetos producto.

Hace fácil el intercambio de familias de productos. Solo necesitaremos cambiar de

Factory.

Fomenta la consistencia entre productos.

Desventajas:

Para añadir un nuevo producto, se requiere la implementación de la interfaz y todos

sus métodos.
 4

Implementación del patrón

1.- Para empezar, se creó la interfaz Shape

2.- Después creamos las clases concretas implementando la misma interfaz

 5

3.- Después creamos una segunda Interfaz para los colores que tendrán los
objetos.

4.- Después creamos las clases concretas implementando la misma interfaz

(Color).
 6

5.- Después se crea una clase abstracta para obtener fábricas para objetos de color
(Interfaz) y forma (Interfaz).

6.- Después se crean clases de Fábrica que extiendan AbstractFactory para

generar un objeto de clase concreta basado en la información dada.
 7

7.- Después se crea una clase de generador / productor de Fábrica para obtener
fábricas al pasar una información como Forma o Color

8.- Utilice FactoryProducer para obtener AbstractFactory con el fin de obtener

fábricas de clases concretas al pasar una información como tipo.
 8

9.- Verificar la salida.

 9

EXPLICACION DEL PATRON

Para la implementación de este patrón primero creamos la interface con un método

void draw que se utilizara para imprimir datos del objeto Shape, después creamos
la clase Rectangle y la clase Circle y hacemos un implements a la interfaz Shape,
en estas clases se crea el método void draw que se utilizara para imprimir datos
del objeto solicitado, después se creó la interfaz Color con el método fill que se
utilizara para llenar los datos del color del objeto, después creamos las clases RED
Y GREEN y hacemos un implements de la interfaz Color en las clases para poder
trabajar con los métodos de la interfaz, después creamos la clase abstracta
AbstractFactory y hacemos dos métodos getColor y getShape con su parámetro
correspondiente para obtener el color y forma del que se crearan los objetos
solicitados, después creamos las fabricas ShapeFactory y ColoFactoruy que se
encargaran por medio de una validación de obtener y crear la forma del objeto que
solicite el usuario, después creamos la fábrica principal que se encargara de de
recuperar los Tipos de fábricas que contienen los datos del objeto a fabricar,,
después Creamos un get para cada tipo de color y forma que existan y le enviamos
por paramento la característica del objeto (Color o forma) que deseemos crear en
el main para que nos cree un objeto con las características solicitadas y en el main
solamente enviamos el tipo de objeto que queramos y se imprimen los datos de
ese objeto.
 10

Factory Method

El segundo patrón de diseño del que se hablara es el Factory Method.

Ventajas

Se gana en flexibilidad, pues crear los objetos dentro de una clase con un "Método
de Fábrica" es siempre más flexible que hacerlo directamente, debido a que se
elimina la necesidad de atar nuestra aplicación unas clases de productos
concretos.

Se facilitan futuras ampliaciones, puesto que se ofrece las subclases la posibilidad

de proporcionar una versión extendida de un objeto, con sólo aplicar en los
Productos la misma idea del "Método de Fábrica".

Se facilita, en cuanto a que se hace natural, la conexión entre jerarquías de clases

paralelas, que son aquellas que se generan cuando una clase delega algunas de
sus responsabilidades en una clase aparte. Ambas jerarquías de clases paralelas
son creadas por un mismo cliente y el patrón Método de Fábrica establece la
relación entre parejas de subclases concretas en las mismas.

Desventajas

Se obliga al cliente a definir subclases de la clase "Creador" sólo para crear un

producto concreto y esto puede no ser apropiado siempre.
 11

Implementación del patrón

1.- Creamos la interfaz Shape.

2.- Creamos las clases concretas implementando la misma interfaz.

Rectangle.java

Square.java

Circle.java
 12

3.- Creamos una Fábrica para generar un objeto de clase concreta basado en la
información dada.

ShapeFactory.java
 13

4.- Utilice la Fábrica para obtener un objeto de clase concreta pasando una
información como tipo.

FactoryPatternDemo.java

5.- Verificar la salida.

 14

Explicación del patrón

En este patrón de diseño se realiza la creación de un objeto por medio de la
interfaz Shape en la que se guarda un método que se utilizara para la creación del
objeto más adelante, después creamos las clases que utilizara la interfaz para
determinar el tipo de Shape que creara, en este caso las clases son Circle,
Rectangle Y Square, estas clases contienen un método void draw que servirá para
imprimir el tipo de objeto que contienen , después se creó una fábrica llamada
Shape Factory que servirá para crear un nuevo objeto de la clase que se necesite,
en esta clase se utiliza un método get para obtener el tipo de forma que se desea
crear y realiza una comparación para determinar qué tipo de objeto es y realizar
una instancia del objeto en cuestión, y al final hace un return de esa instancia para
que el ejecutable lo reciba y muestre el objeto creado en este.
 15

Singleton

El tercer patrón de diseño del que se hablara es el Singleton.

Ventajas

Acceso controlado a la única instancia: Encapsula su única instancia, puede tener

un control estricto sobre cómo y cuándo acceden a ella los clientes.

Espacio de nombres reducido: Es una mejora sobre las variables globales. Evita
contaminar el espacio de nombres con variables globales que almacenan las
instancias.

Permite el refinamiento de operaciones y la representación: Se puede crear una

subclase de la clase Singleton, y es fácil configurar una aplicación con una
instancia de esta clase extendida, incluso en tiempo de ejecución.

Permite un número variable de instancias: Hace que sea fácil permitir más de una
instancia de la clase. Solo se necesitaría cambiar la operación que otorga acceso
a la instancia del Singleton.

Desventajas

Dificultad para realizar testing: Un Singleton es como un valor de variable global.

Lo global y la orientación a objeto no son buenos amigos ya que introduce un
“estado persistente”, es decir valores que se mantienen siempre dificultando el uso
de objeto de reemplazo(mock) en test.

Promociona el alto acoplamiento el Singleton es instanciado directamente desde

su propia clase promocionando el uso de métodos privados y estáticos. Esto
acopla la clase que los use además de impedir el uso adecuado de inyección de
dependencias.
Restricción de ejecuciones paralelas: Aunque un objetivo del Singleton sea la
gestión de un recurso compartido esto restringe operar de forma paralela a la
aplicación y lo transforma en un cuello de botella de operaciones seriales que no
es recomendable cuando la demanda es alta.
 16

Implementación del patrón

1.- Creamos una clase Singleton.

SingleObject.java

2.- Obtenemos el único objeto de la clase singleton.

SingletonPatternDemo.java
 17

3.- Verificar la salida.

 18

EXPLICACION DEL PATRON

Para la implementación de este patrón primero creamos la clase Singleton que
contiene un constructor privado, una instancia de un nuevo objeto que solo se
creara una vez, un método getInstance para recuperar la instancia que envié el
usuario a crear, con un return, y después tenemos el método void ShowMessage
para imprimir el mensaje que contiene la clase y para verificar que se creó un
objeto de este tipo después creamos el main y creamos una instancia de un objeto
Singleton pero lo hacemos con .getInstance para que la clase pueda comprobar
que solo se cree un objeto de este tipo.
 19

Prototype

El cuarto patrón de diseño del que se hablara es el Prototype.

Ventajas

Permite obtener copia de un objeto en ejecución. Permite decidir si las copias

creadas son a fondo o superficiales.

Desventajas

La jerarquía de prototipos debe ofrecer la posibilidad de clonar un elemento y

esta operación puede no ser sencilla de implementar. Instancias.
 20

Implementación
1.- Crear una clase abstracta implementando la interfaz Clonable.
Shape.java

2.- Crear clases concretas extendiendo la clase anterior.

Rectangle.java

Square.java
 21

Circle.java

3.- Cree una clase para obtener clases concretas de la base de datos y
almacénelas en un Hashtable.

ShapeCache.java
 22

4.- PrototypePatternDemo usa la clase ShapeCache para obtener clones de

formas almacenadas en un Hashtable.

PrototypePatternDemo.java

5.- Verificar la salida.

 23

EXPLICACION DEL PATRON

Para la realización de este patrón primero creamos la clase abstracta en la cual
tenemos los datos de tipo privado, un método abstract void draw que nos servirá
para crear un nuevo objeto, tenemos un getType con un return para obtener el tipo
de objeto que solicite el usuario y un metodo getId, con sus respectivo métodos
set y después tenemos un método llamado Object clone() que se encargara de
comprobar si existe una instancia creada y creara un objeto clon de la instancia
creada con un return del objeto clonado, después creamos la clase Hashtable que
contiene un constructor con el dato type y un metodo draw() que imprimirá el tipo
de objeto que se cree y con una instancia la clase clonedShape, enviamos el id del
objeto que deseemos crear del tipo shape y el getShape se encargar de verificar
que id corresponde al objetos almacenados en la clase ShapeCache y crea un
nuevo objeto clon de este tipo. realizamos un clon del objeto creado, dependiendo
del tipo de objeto que solicite el usuario, por medio de un ID.
 24

Builder

El quinto patrón de diseño del que se hablara es el Builder.

Ventajas
Nos permite cambiar la representación interna de los productos
Tenemos mucho control sobre el proceso de construcción del objeto.
Desventajas
La interfaz de la clase Builder debe ser lo suficientemente genérica para permitir la
construcción de cualquier tipo de objetos por parte de los ConcreteBuilder. Esto
hace que tengamos que tener en la interfaz de Builder métodos que no usarán
todos con ConcreteBuilder.
El objeto complejo creado a veces se devuelve poco tipado. Como en nuestro
caso cada builder concreto devuelve objetos diferentes la el tipado de la interfaz
del método Construct() es débil con respecto al tipo devuelto, en nuestro caso
object.
 25

Implementación.
1.- Cree un elemento de interfaz que represente el alimento y el embalaje.
Item.java

Packing.java

2.- Crear clases concretas implementando la interfaz de Packing.

Wrapper.java
 26

Bottle.java

3.- Crear clases abstractas implementando la interfaz del elemento proporcionando

funcionalidades por defecto.

Burger.java
 27

ColdDrink.java

4.- Crear clases concretas extendiendo las clases de Burger y ColdDrink.

VegBurger.java

ChickenBurger.java
 28

Coke.java

Pepsi.java
 29

5.- Cree una clase de comida que tenga objetos de artículo definidos anteriormente.

Meal.java

6.- Cree una clase MealBuilder, la clase constructora real responsable de crear
objetos Meal.

MealBuilder.java

7.- BuiderPatternDemo usa MealBuider para demostrar el patrón de construcción.

 30

BuilderPatternDemo.java

8.- Verificar la salida.

EXPLICACION DEL PATRON

Para la implementación de este patrón creamos una interfaz de artículo que

represente alimentos tales como hamburguesas y bebidas frías y clases de
concreto implementando la interfaz de Artículo y una interfaz de embalaje que
represente el empaque de alimentos y clases de concreto que implementen la
interfaz de Embalaje ya que la hamburguesa se envasaría en una envoltura y
bebida fría sería embalado como botella.

Luego creamos una clase de comidas con ArrayList del artículo y un MealBuilder
para construir diferentes tipos de objetos de comida mediante la combinación del
artículo. BuilderPatternDemo , nuestra clase de demostración usará MealBuilder
para construir una Comida .
 31

Adapter
El sexto patrón de diseño del que se hablara es el Adapter.
Ventajas
A nivel de clases...
Facilidad para redefinir el comportamiento de la clase adaptada.
Simplicidad (un sólo objeto, no hay punteros ni indirecciones adicionales).
A nivel de objetos...
Flexibilidad para que un sólo adaptador trabaje con muchas clases a adaptar (en
concreto, puede hacerlo con toda una jerarquía de clases).
Extensibilidad, puesto que se pueden añadir funcionalidades a todas las clases
adaptadas a la vez.
Desventajas
A nivel de clases...
Inflexibilidad, puesto que un sólo adaptador no puede trabajar con una clase y sus
hijos a la vez.
A nivel de objetos...
Dificultad para redefinir el comportamiento de la clase adaptada.
 32

Implementación

1.- Crea interfaces para Media Player y Advanced Media Player.

MediaPlayer.java

2.-Crear clases concretas implementando la interfaz AdvancedMediaPlayer .

VlcPlayer.java
 33

Mp4Player.java

3.- Crear clase de adaptador implementando la interfaz de MediaPlayer .

MediaAdapter.java
 34

4.- Crear una clase concreta implementando la interfaz de MediaPlayer .

AudioPlayer.java

5.- Usa el AudioPlayer para reproducir diferentes tipos de formatos de audio.

AdapterPatternDemo.java

6.- Verificar la salida.

 35

EXPLICACION DEL PATRON

En la implementación de este patrón primero tenemos una interfaz de MediaPlayer

y una clase concreta de AudioPlayer que implementa la interfaz de MediaPlayer .
AudioPlayer puede reproducir archivos de audio en formato mp3 por defecto.

Tenemos otra interfaz AdvancedMediaPlayer y clases concretas que implementan

la interfaz AdvancedMediaPlayer . Estas clases pueden reproducir archivos de
formato vlc y mp4.

Para lograr que la clase AudioPlayer pueda reproducir otros formatos también, se
creó una clase de adaptador MediaAdapter que implementa la interfaz MediaPlayer
y utiliza objetos AdvancedMediaPlayer para reproducir el formato requerido.

AudioPlayer utiliza la clase de adaptador MediaAdapter y le pasa el tipo de audio

deseado sin saber la clase real que puede reproducir el formato deseado.
AdapterPatternDemo , nuestra clase de demostración utilizará la clase
AudioPlayer para reproducir varios formato
 36

Bridge

El sexto patrón de diseño del que se hablara es el Bridge.

Ventajas
Desacopla la interfaz de la implementación
Se puede extender la jerarquía de las abstracciones y de las implementaciones
por separado,
Se ocultan los detalles de implementación.
Desventajas

Es incómodo ampliar la abstracción de la ventana para cubrir diversas clases de

ventanas o de nuevas plataformas.

Hace código de cliente plataforma-dependiente.

 37

Implementación del código

1.- Crear interfaz de implementador de puente.

DrawAPI.java

2.- Crear clases de implementador de puentes concretos implementando la

interfaz DrawAPI .

RedCircle.java
 38

GreenCircle.java

3.- Crear una clase abstracta Forma utilizando el DrawAPI interfaz.

Shape.java
 39

4.- Crear clase concreta implementando la interfaz Shape .

Circle.java

5.- Usa las clases Shape y DrawAPI para dibujar círculos de diferentes colores.
BridgePatternDemo.java
 40

6.- Verificar la salida.

RedCircle.java
 41

Explicación del patrón

Para la implementación de este patrón creamos una interfaz DrawAPI que actúa
como implementador de puentes y clases concretas RedCircle , GreenCircle
implementando la interfaz DrawAPI . Shape es una clase abstracta y usará el
objeto de DrawAPI . BridgePatternDemo , nuestra clase de demostración utilizará
la clase Shape para dibujar círculos de diferentes colores.
 42

Composite

El sexto patrón de diseño del que se hablara es el Composite.

Ventajas
Permite jerarquías de objetos tan complejas como se quiera. Allá donde el cliente
espere un objeto primitivo, podrá recibir un compuesto y no se dará cuenta
Simplifica el cliente. Al eliminar el código para distinguir entre unos y otros
Se pueden añadir nuevos componentes fácilmente.
Desventajas

Podría hacer el diseño demasiado general, especialmente cuando queremos

restringir los componentes que pueden formar parte de un compuesto
determinado.

Implementación del código

1.- Crear una clase de empleado que tenga una lista de objetos de empleado.
Empleado.java

2.- Utilice la clase Empleado para crear e imprimir la jerarquía de empleados.

CompositePatternDemo.java
 43

3.- Verificar la salida.

Explicación del patrón

Para la implementación de este patrón tenemos un empleado de clase que actúa
como clase de actor de patrón compuesto. CompositePatternDemo , nuestra clase
de demostración utilizará la clase Employee para agregar una jerarquía de nivel de
departamento e imprimir a todos los empleados.
 44

Decorator

El sexto patrón de diseño del que se hablara es el Decorator.

Ventajas
Más flexibilidad que la herencia estática.
Evita que las clases de arriba de la jerarquía estén repletas de funcionalidades. En
vez de definir una clase compleja que trata de dar cabida a todas ellas, la
funcionalidad se logra añadiendo decoradores a una clase simple.y otros
Se pueden añadir nuevos componentes fácilmente.
Desventajas

Un decorador y sus componentes no son idénticos, desde el punto de vista de la

identidad de objetos, desde el punto de vista del programador o del cliente si que
se podrían considerar iguales.

Muchos objetos pequeños. El sistema puede ser más difícil de aprender y de

depurar.

Implementación del código

1.- Crear una interfaz.

Shape.java
 45

2.- Crear clases concretas implementando la misma interfaz.

Rectangle.java

Circle.java

3.- Crea una clase de decorador abstracto implementando

la interfaz Shape .

ShapeDecorator.java
 46

4.- Crea una clase de decorador de concreto extendiendo

la clase ShapeDecorator.
RedShapeDecorator.java

5.- Utilice el RedShapeDecorator para decorar objetos Shape .

DecoratorPatternDemo.java
 47

6.- Verificar la salida.

 48

Explicación del patrón

Para la implementación de este patrón vamos a crear una interfaz Shape y clases
concretas implementando la interfaz Shape . Luego, crearemos una clase
decorativa abstracta ShapeDecorator implementando la interfaz Shape y teniendo
el objeto Shape como su variable de instancia.
RedShapeDecorator es una clase concreta que implementa ShapeDecorator .
DecoratorPatternDemo , nuestra clase de demostración utilizará
RedShapeDecorator para decorar objetos Shape .
 49

Facade

El sexto patrón de diseño del que se hablara es el Facade.

Ventajas
Ventajas

Es más flexible que la Herencia estática.

Permite que la adicion de nuevas responsabilidades (nuevas clases de
Decorators) independiente de las clases los Objetos que ellas extienden.
Desventajas
Un Decorator y su Component no son idénticos. Desde el punto de vista de la
identidad de los objetos, un DecoratorComponent no es identico al Component.
Por esto no se puede confiar en en la identidad de los objetos cuando se usan
Decorators
El patrón Decorator hace que hayan muchos objetos pequeños que son muy
parecidos
.Desventajas

Como inconveniente, si se considera el caso de que varios clientes necesiten

acceder a subconjuntos diferentes de la funcionalidad que provee el sistema,
podrían acabar usando sólo una pequeña parte de la fachada, por lo que sería
conveniente utilizar varias fachadas más específicas en lugar de una única global.

Implementación del código

1.- Crear una interfaz.

Shape.java
 50

2.- Crear clases concretas implementando la misma interfaz.

Rectangle.java

Square.java
 51

Circle.java

3.- Crear una clase de fachada.

ShapeMaker.java
 52

4.- Utiliza la fachada para dibujar varios tipos de formas.

FacadePatternDemo.java

5.- Verificar la salida.

 53

Explicación del patrón

Para la implementación de este patrón Vamos a crear una interfaz Shape y clases
concretas que implementen la interfaz Shape. Una clase de fachada ShapeMaker
se define como un siguiente paso.
La clase ShapeMaker usa las clases concretas para delegar las llamadas de los
usuarios a estas clases. FacadePatternDemo , nuestra clase de demostración,
usará la clase ShapeMaker para mostrar los resultados.
 54

Flyweight

El sexto patrón de diseño del que se hablara es el Flyweight.

Ventajas
Mejora en la eficiencia, sobre todo en relación con el ahorro en el
almacenamiento, que aumenta paralelamente con la compartición de objetos y es
función de:
Desventajas

Se introducen costes en tiempo de ejecución asociados a las transferencias,

búsquedas y/o computación del estado extrínseco (y su almacenamiento).

Implementación del código

1.- Crear una interfaz.

Shape.java

2.- Crear clase concreta implementando la misma interfaz.

Circle.java
 55

3.- Cree una fábrica para generar un objeto de clase concreta basado en
la información dada.

ShapeFactory.java

4.- Utilice la fábrica para obtener un objeto de clase concreta pasando

información como el color.

FlyweightPatternDemo.java
 56

5.- Verificar la salida.

 57

Explicación del patrón

Para la implementación de este patrón vamos a crear una interfaz de Forma y una
clase concreta de Círculo implementando la interfaz de Forma . Una clase de
fábrica ShapeFactory se define como un paso siguiente.
ShapeFactory tiene un HashMap de Círculo que tiene clave como color del objeto
Círculo . Cuando llega una solicitud para crear un círculo de un color particular
para ShapeFactory , comprueba el objeto de círculo en su HashMap , si se
encuentra el objeto de Círculo , ese objeto se devuelve; de lo contrario, se crea un
nuevo objeto, se almacena en un mapa de hash para su uso futuro y se devuelve
a cliente.
FlyWeightPatternDemo , nuestra clase de demostración, usará ShapeFactory para
obtener un objeto Shape . Pasará información ( rojo / verde / azul / negro / blanco )
a ShapeFactory para obtener el círculo del color deseado que necesita.
 58

Proxy

El sexto patrón de diseño del que se hablara es el Proxy.

Ventajas
Este patrón presenta varias ventajas que se deben considerar, tales como:
Se introduce un nivel de indirección en el acceso al objeto, que permite al
apoderado remoto ocultar el hecho de que el objeto reside en un espacio de
direcciones distinto, al apoderado virtual realizar optimizaciones como la creación
de objetos por demanda y al apoderado de protección y a las referencias
“inteligentes” realizar tareas adicionales de vigilancia sobre el objeto al que se
accede. No obstante todo esto puede resultar un inconveniente, por motivos de
claridad e inteligibilidad del diseño.
Facilita otra optimización, relacionada con la creación de objetos por demanda: la
técnica de COPY-ON-WRITE, que sólo hace efectiva la copia de un objeto
oneroso cuando el acceso a él es de escritura, no de lectura.
Desventajas

El uso de un proxy introduce un nivel de indirección adicional con diferentes usos:

Un Proxy remoto oculta el hecho de que un objeto reside en otro espacio de

direcciones.

Un Proxy virtual puede realizar optimizaciones, como la creación de objetos bajo

demanda.

El Proxy de protección y las referencias inteligentes permiten realizar diversas

tareas de mantenimiento adicionales al acceder a un objeto.

Además, su uso también permite realizar una optimización COW (copy-on-write),

puesto que copiar un objeto grande puede ser costoso, y si la copia no se
modifica, no es necesario incurrir en dicho gasto. Además el sujeto mantiene un
número de referencias, y sólo cuando se realiza una operación que modifica el
objeto, éste se copia. Es útil por tanto para retrasar la replicación de un objeto
hasta que cambia.

Implementación del código

1.-Crear una interfaz.

 59

Imagen.java

2.- Crear clases concretas implementando la misma interfaz.

RealImage.java

ProxyImage.java
 60

3.- Utilice ProxyImage para obtener el objeto de

la clase RealImage cuando sea necesario.

ProxyPatternDemo.java

4.- Verificar la salida.

 61

Explicación del patrón

Para la implementación de este patrón vamos a crear una interfaz de imagen y
clases concretas implementando la interfaz de imagen. ProxyImage es una clase
de proxy para reducir la huella de memoria de la carga de objetos RealImage .

ProxyPatternDemo , nuestra clase de demostración, usará ProxyImage para

obtener un objeto de imagen para cargar y mostrar según sea necesario.
 62

Chain of responsibility
El sexto patrón de diseño del que se hablara es el Chain of responsibility.
Ventajas
Reduce el acoplamiento: Libera a un objeto de tener que saber que otro objeto
maneja una petición. Ni el emisor ni el receptor se conocen y tampoco tienen que
conocer la estructura de la cadena. Simplifica las interconexiones entre objetos.
En vez de que los objetos mantengan referencias a todos los posibles receptores,
solo tienen una única referencia a su sucesor (Ventaja).
Añade flexibilidad para asignar responsabilidades a objetos : Se pueden añadir o
cambiar responsabilidades para tratar una petición modificando la cadena en
tiempo de ejecución (Ventaja).
Desventajas

No se garantiza la recepción: Dado que las peticiones no tienen un receptor

explícito, no hay garantía de que sean manejadas (la petición puede alcanzar el
final de la cadena sin haber sido procesada). Una petición también puede quedar
sin tratar cuando la cadena no está configurada correctamente (Desventaja).
Implementación del código

1.- Crear una clase de registrador abstracto.

AbstractLogger.java

2.- Crear clases concretas extendiendo el registrador.

 63

ConsoleLogger.java

ErrorLogger.java

FileLogger.java
 64

3.- Crear diferentes tipos de registradores. Asígneles niveles de error y

configure el siguiente registrador en cada registrador. El siguiente
registrador en cada registrador representa la parte de la cadena.

ChainPatternDemo.java

4.- Verificar la salida.

 65

Explicación del patrón

Para la implementación de este patrón hemos creado una clase abstracta
AbstractLogger con un nivel de registro. Luego hemos creado tres tipos de
registradores que extienden el AbstractLogger . Cada registrador verifica el nivel
del mensaje a su nivel e imprime en consecuencia, de lo contrario no imprime y
pasa el mensaje a su siguiente registrador.
 66

Command

El sexto patrón de diseño del que se hablara es el Command.

Ventajas
Orden desacopla el objeto que invoca la operación de aquel que sabe cómo
realizarla.
Se pueden ensamblar ordenes en una orden compuesta (generalmente se usa el
Patrón Composite).
Es fácil añadir nuevas órdenes ya que no hay que cambiar las clases existentes.
Desventajas
Las ordenes son objetos de primera clase, pueden ser manipulados y extendidos.

Implementación del código

1.- Crear una interfaz de comandos.

Order.java

2.- Crear una clase de solicitud.

Stock.java
 67

3.- Crear clases concretas implementando la interfaz de Orden .

BuyStock.java

4.- Crear comando invocador de la clase.

Broker.java
 68

5.- Usa la clase Broker para tomar y ejecutar comandos.

CommandPatternDemo.java

6- Verificar la salida.
 69

Explicación del patrón

Para la implementación de este patrón hemos creado una Orden de interfaz que
actúa como un comando. Hemos creado una clase de Stock que actúa como una
solicitud. Tenemos clases de comandos concretas, BuyStock y SellStock, que
implementan la interfaz de Orden, que hará el procesamiento del comando real.
Se crea un broker de clase que actúa como un objeto invocador. Puede tomar y
hacer pedidos.
El objeto Broker usa el patrón de comando para identificar qué objeto ejecutará
qué comando según el tipo de comando. CommandPatternDemo , nuestra clase
de demostración, usará la clase Broker para demostrar el patrón de comando.
 70

Interpreter

El sexto patrón de diseño del que se hablara es el Interpreter.

Ventajas
Facilidad para cambiar o extender la gramática, mediante herencia, dado que las
diferentes reglas de la gramática se representan con clases.
Facilidad para implementar la gramática, dado que las implementaciones de las
clases nodo del árbol sintáctico son similares, pudiendo usarse para ello
generadores automáticos de código.
Facilidad para introducir nuevas formas de interpretar las expresiones en la
gramática (tener en cuenta el patrón Visitante).
Desventajas

Limitación en el tipo de gramáticas (y, por extensión, de problemas) para los que
sirve esta aproximación: simples y sin grandes necesidades de eficiencia. Aunque
el uso de otros patrones puede mitigar este problema, hay circunstancias en que
un Intérprete no es lo más apropiado.

Implementación del código

1.- Crear una interfaz de expresión.

Expression.java
 71

2.- Crear clases concretas implementando la interfaz anterior.

TerminalExpression.java

OrExpression.java

3.- InterpreterPatternDemo usa la clase Expression para crear reglas y

luego analizarlas.

IntérpretePatternDemo.java
 72

4.- Verificar la salida.

 73

Explicación del patrón

Para la implementación de este patrón vamos a crear una expresión de interfaz y
clases concretas que implementen la interfaz de expresión. Se define una clase
TerminalExpression que actúa como un intérprete principal del contexto en
cuestión. Otras clases OrExpression , AndExpression se utilizan para crear
expresiones combinacionales.
InterpreterPatternDemo , nuestra clase de demostración, usará la clase
Expression para crear reglas y demostrar el análisis de expresiones.
 74

Iterator

El sexto patrón de diseño del que se hablara es el Iterator.

Ventajas
Se incrementa la flexibilidad, dado que para permitir nuevas formas de recorrer
una estructura basta con modificar el iterador en uso, cambiarlo por otro
(parametrización) o definir uno nuevo.
Se facilitan el paralelismo y la concurrencia, puesto que, como cada iterador tiene
consciencia de su estado en cada momento, es posible que dos o más iteradores
recorran una misma estructura simultánea o solapadamente.
Desventajas
Se enfatiza la distribución de responsabilidades (y, por ello, la simplicidad de los
elementos del sistema), dado que la interfaz del agregado se ve libre de una serie
de operaciones, más propias de la interfaz del iterador.

Implementación del código

1.- Crear interfaces.

Iterator.java

Container.java
 75

2.- Crear clase concreta implementando la interfaz del contenedor. Esta

clase tiene clase interna NameIterator aplicación del iterador interfaz.

NameRepository.java

3.- Use el NameRepository para obtener iterador e imprimir nombres.

IteratorPatternDemo.java
 76

4.- Verificar la salida.

 77

Explicación del patrón

Para la implementación de este patrón vamos a crear una interfaz

de iterador que narra el método de navegación y una interfaz
de contenedor que vuelve al iterador. Las clases concretas que
implementen la interfaz del contenedor serán responsables de
implementar la interfaz del iterador y usarla.

IteratorPatternDemo , nuestra clase de demostración

utilizará NamesRepository , una implementación de clase concreta para
imprimir los Nombres almacenados como una colección
en NamesRepository .
 78

Mediator

El sexto patrón de diseño del que se hablara es el Mediator.

Ventajas
Simplifica la comunicación entre objetos: Los objetos pueden remplazar una
comunicación "muchos a muchos" por una del tipo "uno a muchos", que es menos
compleja y más elegante. Además esta forma de comunicación es más fácil de
entender.
Abstrae como los objetos cooperan: Haciendo que la mediación sea un concepto
independiente y encapsulandolo en un objeto permite enfocar como los objetos
interactúan. Esto ayuda a clarificar cómo los objetos se relacionan en un sistema.
Centraliza el control: El Mediador es el que se encarga de comunicar a los
Colegas. Esto hace que el Mediador pueda ser muy complejo, difícil de entender y
modificar
Desventajas
Desacopla a los Colegas: el patrón Mediador promueve bajar el acoplamiento
entre Colegas. Se puede variar y rehusar Colegas y Mediadores
independientemente

Implementación del código

1.- Crear clase mediadora.

ChatRoom.java
 79

2.- Crear clase de usuario

Usuario.java

3.- Utilice el objeto Usuario para mostrar las comunicaciones entre ellos.

MediatorPatternDemo.java
 80

4.- Verificar la salida.

 81

Explicación del patrón

Para la implementación de este patrón estamos demostrando el patrón de
mediador mediante el ejemplo de una sala de chat donde varios usuarios pueden
enviar mensajes a la sala de chat y es responsabilidad de la sala de chat mostrar
los mensajes a todos los usuarios. Hemos creado dos clases ChatRoom y
Usuario. Los objetos del usuario utilizarán el método ChatRoom para compartir
sus mensajes.
MediatorPatternDemo, nuestra clase de demostración utilizará objetos de usuario
para mostrar la comunicación entre ellos.
 82

Memento

El sexto patrón de diseño del que se hablara es el Memento.

Ventajas
Deja alguna información en un objeto para que sea accesible por otro objeto
utilizando control de acceso por defecto.
El Originator es más simple. En otros patrones que conservan la encapsulación el
Originator es el que tiene que registrar todos los estados distintos, es mucho más
sencillo dar esa responsabilidad a la parte solicitante.
Se usa en transacciones de Bases de Datos.
Usar este patrón en operaciones de UNDO/REDO.
Desventajas

Los mementos son costosos, es costoso crear los objetos Memento si se tiene
que almacenar todas las partes del estado del Originator.

El almacenamiento de los Memento es costoso, el cliente que desea guardar su

estado, no conoce el tamaño real del Memento.

Definición de interfaces reducidas y amplias. En algunos lenguajes puede ser

difícil garantizar que sólo el creador acceda al estado del memento.

Preservación de los límites de la encapsulación. El memento evita exponer

información que sólo debería ser gestionada por un creador, pero que sin
embargo debe ser guardada fuera del creador.

Implementación del código

1.- Crear una clase de recuerdo.

Memento.java
 83

2.- Crear clase de originador

Originator.java

3.- Crear clase CareTaker

CareTaker.java
 84

4.- Usa los objetos CareTaker y Originator .

MementoPatternDemo.java

5.- Verificar la salida.

 85

Explicación del patrón

Para la implementación de este Patrón de recuerdo se utiliza tres clases de actor.
Memento contiene el estado de un objeto para ser restaurado. Originator crea y
almacena estados en objetos Memento y el objeto Caretaker es responsable de
restaurar el estado del objeto desde Memento. Hemos creado las clases
Memento, Originator y CareTaker .
MementoPatternDemo , nuestra clase de demostración, utilizará los objetos
CareTaker y Originator para mostrar la restauración de los estados del objeto.
 86

Observer

El sexto patrón de diseño del que se hablara es el Observer.

Ventajas
Acoplamiento abstracto entre Subject y Observer. Todo lo que un objeto sabe de
sus observadores es que tiene una lista de objetos que satisfacen la interfaz
Observer. Con lo que podrían incluso pertenecer a dos capas distintas de la
arquitectura de la aplicación.
Actualizaciones inesperadas. Se podrían producir actualizaciones en cascada muy
ineficientes.
Desventajas
No se especifica el receptor de una actualización. Se envía a todos los objetos
interesados

Implementación del código

1.- Crear clase de sujeto.

Subject.java

2.- Crear clase de observador.

Observer.java
 87

3.- Crear clases concretas de observadores.

BinaryObserver.java

OctalObserver.java
 88

4.- Usa objetos de observación y sujeto concreto.

ObserverPatternDemo.java

5.- Verificar la salida.

 89

Explicación del patrón

Para la implementación de este Patrón de observador se utilizan tres clases de
actor. Sujeto, observador y cliente. El sujeto es un objeto que tiene métodos para
adjuntar y separar observadores a un objeto cliente. Hemos creado un observador
abstracto de la clase y un sujeto concreto de la clase que está extendiendo el
observador de la clase .
ObserverPatternDemo , nuestra clase de demostración, utilizará el objeto Subject
y la clase concreta para mostrar el patrón de observador en acción.
 90

State

El sexto patrón de diseño del que se hablara es el State.

Ventajas
Se localizan fácilmente las responsabilidades de los estados específicos, dado
que se encuentran en las clases que corresponden a cada estado. Esto brinda una
mayor claridad en el desarrollo y el mantenimiento posterior. Esta facilidad la
brinda el hecho que los diferentes estados están representados por un único
atributo (state) y no envueltos en diferentes variables y grandes condicionales.
Hace los cambios de estado explícitos puesto que en otros tipos de
implementación los estados se cambian modificando valores en variables,
mientras que aquí al estar representado cada estado.
Los objetos State pueden ser compartidos si no contienen variables de instancia,
esto se puede lograr si el estado que representan esta enteramente codificado en
su tipo. Cuando se hace esto estos estados son Flyweights sin estado intrínseco.
Facilita la ampliación de estados
Permite a un objeto cambiar de clase en tiempo de ejecución dado que al cambiar
sus responsabilidades por las de otro objeto de otra clase la herencia y
responsabilidades del primero han cambiado por las del segundo.
Desventajas

 Se incrementa el número de subclases.

Implementación del código

1.- Crear una interfaz.

State.java
 91

2.- Crear clases concretas implementando la misma interfaz.

StartState.java

StopState.java
 92

3.- Crear clase de contexto .

Context.java

4.- Utilice el contexto para ver el cambio en el comportamiento

cuando cambia el estado .

StatePatternDemo.java
 93

5.- Verificar la salida.

 94

Explicación del patrón

Para la implementación de este patrón vamos a crear una interfaz de estado que
define una acción y clases de estado concretas que implementan la interfaz de
estado . El contexto es una clase que lleva un estado.

StatePatternDemo , nuestra clase de demostración, utilizará los objetos Context y

state para demostrar el cambio en el comportamiento de Context según el tipo de
estado en el que se encuentre.
 95

Strategy

El sexto patrón de diseño del que se hablara es el Strategy.

Ventajas
Factoriza aspectos comunes de una familia de algoritmos y utilizarlos en las clases
base de la jerarquía.
Aumenta cohesión del cliente.
Sistematiza el uso de implementaciones alternativas.
El cliente es el responsable de crear estrategias, por tanto debe comprender las
posibilidades que ofrecen, esto es, debe ser relevante para el contexto del cliente.
Desventajas
Menor eficiencia. Aumenta el número de objetos creados.

Implementación del código

1.- Crear una interfaz.

Stategy.java

2.- Crear clases concretas implementando la misma interfaz.

OperationAdd.java
 96

OperationSubstract.java

OperationMultiply.java
 97

3.- Crear clase de contexto.

Context.java

4.- Utilice el contexto para ver el cambio en el comportamiento cuando

cambia su estrategia .

StrategyPatternDemo.java
 98

5.- Verificar la salida.

 99

Explicación del patrón

Para la implementación de este patrón vamos a crear una interfaz de estrategia
que define una acción y clases de estrategia concretas que implementan la
interfaz de estrategia. El contexto es una clase que usa una estrategia.

StrategyPatternDemo , nuestra clase de demostración, utilizará objetos de

contexto y estrategia para demostrar el cambio en el comportamiento de contexto
basado en la estrategia que implementa o usa.
 100

Template method
Template method

El sexto patrón de diseño del que se hablara es el Template Method.

Ventajas
La principal ventaja es que facilita la reutilización de código, por eso es
fundamental este patrón en muchos Frameworks.
Desventajas

Se puede producir ambigüedad si no se escribe bien

Si el método plantilla llama demasiados métodos abstractos, se cansará pronto

de utilizar AbstractClass como superclase.

Implementación del código

1.- Crear una clase abstracta con un método de plantilla siendo final.

Juego.java

2.- Crear clases concretas extendiendo la clase anterior.

Cricket.java
 101

Football.java

3.- Utilice el juego 's plantilla de método play () para demostrar de una
manera definida de jugar el juego.

TemplatePatternDemo.java
 102

4.- Verificar la salida.

 103

Explicación del patrón

Para la implementación de este patrón vamos a crear una clase abstracta de
Juego que define las operaciones con un método de plantilla establecido para ser
definitivo, de modo que no se pueda anular. El cricket y el fútbol son clases
concretas que extienden el juego y anulan sus métodos.
TemplatePatternDemo , nuestra clase de demostración, usará Game para
demostrar el uso del patrón de plantilla.
 104

Visitor

El sexto patrón de diseño del que se hablara es el Visitor.

Ventajas
Es fácil añadir nuevas operaciones a la “Estructura De Objetos”; sólo hay que
crear un nuevo “Visitante”, en vez de cambiar todas las clases a las que queremos
que afecte.
Se juntan las operaciones relacionadas entre sí, separándose las que nada tienen
que ver. Esto simplifica tanto las clases de los “Elementos” como los algoritmos
definidos en los “Visitantes”.
Se pueden recorrer jerarquías formadas por objetos de distintos tipos (distinta
clase padre), mientras que un Iterador no puede hacer esto.
Se puede ir acumulando el estado a medida que se recorre la estructura, en vez
de tener que pasarlo como parámetro o guardarlo en variables globales.
Desventajas

Añadir un nuevo tipo de elemento a la estructura de objetos crea problemas, pues

hay que tocar toda la estructura jerárquica de “Visitantes”, lo cual es muy costoso.

Frecuentemente se fuerza a los “Elementos” a proporcionar operaciones públicas

que den acceso a su estado interno, con lo que se pone en peligro el
encapsulamiento.

Implementación del código

Paso 1
Definir una interfaz para representar el elemento.

ComputerPart.java
 105

2.- Crear clases concretas extendiendo la clase anterior.

Teclado.java

Monitor.java
 106

Mouse.java

Computer.java
 107

3.- Definir una interfaz para representar al visitante.

ComputerPartVisitor.java

4.- Crear visitante concreto implementando la clase anterior.

ComputerPartDisplayVisitor.java
 108

5.- Use el ComputerPartDisplayVisitor para mostrar partes de

la computadora .

VisitorPatternDemo.java

6.- Verificar la salida.

 109

Explicación del patrón

Para la implementación de este patrón vamos a crear una interfaz ComputerPart
que defina la operación de aceptación. Keyboard , Mouse , Monitor y Computer
son clases concretas que implementan la interfaz ComputerPart . Definiremos otra
interfaz ComputerPartVisitor que definirá las operaciones de una clase de
visitante. La computadora utiliza el visitante concreto para hacer la acción
correspondiente.
VisitorPatternDemo , nuestra clase de demostración, utilizará las clases Computer
y ComputerPartVisitor para demostrar el uso del patrón de visitante.
 110

Conclusión

Con la realización de este reporte pude aprender que para cada tipo de
problemática existe un patrón de diseño que proporciona una solución óptima
para la resolución del problema, también puedo concluir que cada patrón se utiliza
de forma específica dependiendo de las circunstancias del problema y cada
patrón tiene sus ventajas y desventajas, algunos patrones pueden
complementarse con otros para resolver un problema determinado.