Bienvenido.
Continuamos con el patrón decorador o decorador de la categoría estructurales.
Bueno, tiene como finalidad agregar funcionalidad dinámica al objeto, pero sin utilizar la herencia.
Claro, porque podríamos utilizar herencia.
Heredamos de una clase y le podemos agregar una funcionalidad extra.
Por ejemplo, sobre escribiendo métodos es una alternativa, pero utilizando el patrón de curator es
mucho más eficiente.
Y también vamos a utilizar mucho menos clases de herencia, porque por ejemplo, si queremos añadir
múltiples características adicionales a este objeto, bueno, tendremos que utilizar bastante la herencia
y si no, va a complicar un poco el diseño.
Pongamos un ejemplo supongamos que tenemos una clase ventana y le queremos añadir una característica
para que se muestren los bordes de esta ventana borde arriba, abajo y a el lado bueno.
Podemos crear una su clase ventana comporte que quedebe de ventana.
Bueno, hasta ahí no hay ningún problema.
Sería una sola característica, una funcionalidad.
Pero qué pasa si además necesitamos agregar a esta ventanita arriba un botón de ayuda?
45 interrogacion un botón de ayuda?
Bueno, ahí tenemos diferentes alternativas, como por ejemplo, podríamos crear otra clase de ventana
que le podríamos llamar ventana con botón de ayuda.
El problema es que esta solución no cubre la funcionalidad tener bordes, solamente un botón de ayuda.
Es decir, no podemos tener los borde y además el botón de ayuda al mismo tiempo, a menos que en vez
de heredar de ventana, heredemos de ventana comporte.
Y en ese caso le podríamos llamar ventana con bordes y botón de ayuda.
Pero el problema es que no tenemos una opción de ventana con botón de ayuda, pero si importe.
Es decir, no nos sirve para todos los casos.
Solamente podemos tener una ventana, una ventana con borde, o bien una ventana con borde y botón de
ayuda, pero no una ventana solamente con botón de ayuda y sin bordes se fijan.
Otra alternativa sería crear las distintas combinaciones posibles para tener todas estas funcionalidades
y en este caso ya serían cuatro clase en la herencia, por ejemplo la ventana, otra clase ventana comporte
querea de ventana.
Luego tendríamos una tercera clase de ventana con botón de ayuda que hereda de ventana y finalmente
tendríamos ventana con borde y botón de ayuda que hereda de ventana con botón de ayuda.
Se fijan entonces ya son cuatro clases para las distintas combinaciones.
Ahora, qué pasa si le agregamos una tercera funcionalidad?
Recuerden que acá tenemos dos, tenemos con botón de ayuda y con borde, pero se agregamos una tercera.
Ya vamos a tener ocho clases de herencia.
Si agregamos una cuarta funcionalidad, vamos a tener 16 clases de herencia.
Entonces el diseño se complica.
Entonces, en este caso la herencia no nos sirve.
Es decir, la podemos implementar igual, pero no de la mejor forma posible.
Y ahí es cuando entra este patrón.
Diseño de.
Bueno, de qué se trata?
Vamos a tener un interfaz componente por poner un nombre componente y tenemos el objeto que le queremos
dar funcionalidad dinámica.
Acá tenemos el diagrama de clases para este ejemplo.
Acá tenemos un texto, acá tenemos un componente visual y el texto hereda de componente visual y tenemos
una clase decoradora que anida al componente.
En este caso el texto que le queremos dar una funcionalidad.
Pero este decorador es abstracto, pero tenemos implementación concreta y cada implementación o decorar
concreto es para dar una funcionalidad, una característica a este objeto.
Por ejemplo, que se pueda desplazar o agregar borde a este texto o bien algún botón de ayuda.
Se fijan y lo que hace es justamente anidar el componente, tanto el componente que queremos decorar
o agregar esta funcionalidad como el decorador que se encarga de decorar a este objeto.
Ambos comparten la misma interfaz.
Por lo tanto, el decorador de forma recursiva va a envolver al objeto y no solamente al objeto en cuestión,
sino también a los decoradores que contienen o que envuelven al objeto.
Es decir, algún decorador que se haya aplicado anteriormente a este objeto y lo queremos volver a decorar
con otra característica mantener la decoración previa y además añadir una nueva decoración.
Hay una implementación acá de recursividad y eso es lo que vamos a ver.
Y esto lo podemos ver en el diagrama de clases.
Si nos fijamos, hay una relación de agregación.
Es decir, el decorador abstracto tiene una relación de agregación, es decir, agrega varios componentes
y por eso el rombo en la relación agregación.
Y este componente no solamente puede ser el texto, sino también puede ser el texto con un decorador,
ese con un decorado que se le haya aplicado anteriormente.
De esa forma, poder decorar de forma recursiva un decorador contiene varios decoradores que se han
aplicado o bien el objeto que queremos decorar.
Bueno, de todas formas, después lo vamos a ver en el ejemplo.
No se preocupen, no se preocupe, siéndolo tiene 100 por ciento porque con el código va a quedar mucho
más claro.
Bien, entonces, para resumir un poco más abajo, estamos en la página de Wikipedia.
Acá tenemos los componentes principales, el componente define la interfaz para los objetos que pueden
tener responsabilidades añadidas.
Es decir, que vamos a decorar.
Le vamos a agregar de forma dinámica una característica.
Luego tenemos el componente concreto.
Define un objeto, el cual se le puede agregar una responsabilidad adicional.
Luego tenemos El decorador mantiene una referencia al componente asociado que le queremos dar una funcionalidad
extra, pero también puede ser componente o bien un decorador que a su vez contiene el componente y
tanto el decorador como el componente comparten la misma interfaz componente.
Por lo tanto, se pueden ir agregando funcionalidades de forma recursiva.
Y por último, el decorador concreto.
Una implementación del decorador que añade una responsabilidad o funcionalidad al componente.
Bien, veamos el ejemplo.
Vamos a cerrar la clase que tenemos todas.
Cerrar todo.
Nos vamos a ir a patrones.
Vamos a crear un nuevo package.
De corecto, bien, lo primero vamos a crear nuestra interfaz.
Componente.
Qué va a ser en común, tanto al objeto que queremos decorar, como también a los decoradores, que
a su vez contienen hoy tu objeto para decorar?
Bien, entonces una interfaz seleccionamos interfaz, le vamos a llamar, fórmate, habla en nombre
de lo mismo, pues el componente formateado hable un nombre descriptivo según nuestro contexto, el
contexto, el ejemplo, hacer un texto del tipo string que le vamos a formatear, por ejemplo, convertir
a mayúscula, dar vuelta los caracteres, subrayar el texto.
En fin, lo que queramos.
Entonces formateado L.
Voy a tener el método dar formato.
Bien, pero recuerden que la interfases, el public, el modificador, no se escribe.
Es decir, da lo mismo, pero se puede omitir por defecto es public, entonces trec, dar formato y
listo.
Vamos a tener nuestro objeto que queremos decorar.
Que le queremos dar una característica dinámica extra.
Le vamos a llamar texto o frase o como queramos.
La idea que implemente la interfaz, es decir, que se pueda decorar o formatear.
Simplement formatear.
Acá nos pide implementar el método dar formato.
Perfecto.
Ahora el texto va a tener un atributo private string, texto o frase un constructor.
No vamos a pasar el texto y también el método GET.
Qué texto, no?
Porque estamos pasando por constructor, aunque también lo podríamos tener, pero eso sería básicamente
y en dar formato.
Vamos a devolver el texto y el atributo texto por defecto, sin formato.
Entonces Wyeth texto el método GET.
Eso por ahora.
Luego vamos a tener el decorador.
Entonces en decorador vamos a implementar los decoradores.
Un package decorado solamente para que esté ordenado.
Acá vamos a crear los decoradores para agregar estas características.
Texto decorador, una clase, pero hacer una clase abstracta ya porque la idea de que tengamos diferentes
decoradores abstracto.
Y vamos a implementar la misma interfaz de texto formateado doble implementas formatear.
Pero recuerde que el decorador debe anidar envolver al componente para que lo pueda decorar.
Entonces vamos a tener un atributo private tiene que ser del tipo formatear.
Por qué no solamente podremos tener un texto el objeto que queremos decorar, sino también podría tener
otros decoradores.
Y de esa forma poder mantener el decorador anterior y darle una funcionalidad extra de forma recursiva.
Entonces Private, fórmate table
texto y si lo pasamos por constructor?
Zeca Generate.
Constructor.
Repasemos el texto del tipo formation.
Recuerden que texto implementa la interfaz formateada.
Por lo tanto, del tipo de.
Pero también podría ser otro decorador para decorar de forma recursiva.
Te molesto con el padre?
Ahora vamos a tener un decorador hijo.
Concreto puede ser, por ejemplo, mayúscula, decorador.
Bien
tent texto decorador y acá nos pide por la interfaz, implementar el método, dar formato.
Recuerden que el texto decorador implementa la interfaz formateados.
Pero como es abstracto, no está obligado a implementar el método, pero si lo tienen que implementar
sus hijos.
Acá nos pide también el constructor.
Claro, porque tengo que pasar el componente a decorar.
Entonces, un clic derecho generate.
Constructor y listo, con Súper lo pasamos al padre.
Ahora le damos el formato.
Ya tenemos texto.
Entonces texto, punto, dar formato.
Y acá le añadimos el extra.
Acá marca error porque el texto lo dejamos como privat privado y lo podríamos cambiar a protected para
que sea visible también en la clase hija.
Entonces lo hagamos como protected.
De esa forma nos marcaron y visible en esta clase.
Bien.
Y lo decoramos.
Punto.
Tú aparques.
Lo convertimos en mayúscula.
Entonces mantenemos la característica inicial, original o anterior y le agregamos una nueva funcionalidad.
Un decorador muy simple.
Vamos a crear otro más.
Por ejemplo, reversa decorador
y lo mismo heredamos del padre Tent.
Texto decorador.
Implementamos el constructor es lo primero.
Para pasar el componente luego.
Generate Implementamos el método del padre o Berruguete o implementar en realidad dar formato ok, lo
mismo, pero vamos a invertir los caracteres.
Una forma simple es utilizando String Builder String Builder para que tenemos new string builder y le
pasamos el texto punto dar formato, la cadena completa, el texto completo y vamos a devolver el string
builder que se ve.
Punto.
Acá tiene el método Reverse Reverse para dar vuelta y lo convertimos a String.
Así de simple.
Entonces tomamos el texto original en un String Builder, lo damos vuelta y lo devolvemos como un string.
El esta aitas decorado, le enviamos otro decorador y así podremos tener muchos se fijan una nueva clase
reemplazar espacio.
Reemplazar espacio decorador.
Stents texto decorador implementamos el método.
De formato.
El constructor.
Genere constructor y reemplazar espacio.
Bueno.
Texto, punto.
Dar formato.
Punto replies.
Espacio.
Por ejemplo.
Por guion.
Bajo de esto.
Y por último, podríamos tener otro decorador New Yaba Class.
Le vamos a llamar subrayado decorador.
Extend
texto decorador perfecto, implementamos el método.
Constructor.
Generad.
El esto de cómo podemos agregar un subrayado, podríamos utilizar un string builder.
Primero calculamos el largo del string e igual texto, punto dar formato.
Punto Lenka.
Ahí tenemos la cantidad de caracteres del texto, del texto actual, del texto.
Ya se ha decorado anteriormente o no?
Usamos un string builder.
String builder.
Se ve igual new String Builder?
Le pasamos el texto.
Punto.
Dar formato con el formato.
Bien.
Partimos de esa base y abajo le agregamos un subrayado por cada caracter.
Un guión bajo ese punto.
Append Lo que si vamos a agregar un salto línea entonces con n.
Usamos un for for, partimos a cero hasta el total.
Incrementamos ese punto append, entonces, por cada carácter vamos a agregar un subrayado.
Y listo.
Luego devolvemos el S.V.
Punto tu estrella.
Ahí lo tenemos.
Ven, vamos a probar el decorador.
Vamos a crear una clase con el método Main.
Acá en la raíz.
New Ya Klauss ejemplo decorador.
Main y comenzamos primero el texto formateado l
texto vamos a importar formatear doble new texto.
Recuerden por constructor le pasamos el contenido.
Hola que tal Andrés?
Perfecto.
Ahí tenemos el texto que queremos decorar.
Mayúscula Decorador
mayúscula igual new mayúscula, decorador que le pasaba por constructor, le pasamos un instance de
formatear.
El texto por constructor.
Listo.
Ahí tenemos ahora, además de mayúscula.
Quiero dar vuelta la palabra reversar.
Entonce entonces reversa decorador, reversa igual new reversa decorador.
Y le pasamos.
Le pasamos el otro decorador que contiene el texto y de esa forma empieza a decorar recursivamente.
Recuerden que un decorador puede contener cualquier componente objeto que implemente la interfaz.
Fórmate.
Y cualquier decorador le implementa a través del padre.
Recuerden que acá tenemos texto decorador.
El padre implementa formatea ible, pero a su vez el texto, el texto mismo que le queremos dar funcionalidad
dinámica también implementa formatear.
Entonces puedo decorar, ya sea un decorador que contiene el texto o directamente el texto.
Te fijen, entonces acá pasamos mayúscula y además quiero subrayar entonces subrayado.
Sub rayar igual new subrayado decorador le pasamos reversa para que se compongan, para que sea de forma
dinámica, para que sea de forma recursiva, entonces reversa Shout.
Vamos a imprimir el resultado final que lo tiene el subrayar, subrayar, punto, dar formato.
Entonces de parte y de forma recursiva se comienza a formatear.
Vamos a levantar.
Se fijen, está en mayúscula, la aplicamos mayúscula, la aplicamos reversa y la aplicamos subrayada.
Qué pasa si comentamos acá?
Reversa?
Perfecto.
Y en subrayar le pasamos mayúscula.
Hola, qué tal Andrés, se fijan, entonces tenemos la combinaciones posibles, simplemente implementamos
el decorador y lo pasamos por constructor, ya sea otro decorador o el texto.
Ahora, si solamente quiero subrayar Quito mayúscula y acá pasamos texto.
Hola, qué tal, André?
Pero común y corriente.
Y subrayado.
Pero además, por ejemplo, reemplazar espacio decorador, reemplazar igual new reemplazaste cordado.
Vamos a pasar, subrayas.
Acá sería reemplazar.
Reemplazar.
Dar formato.
Ya que subrayar pasamos el texto y luego en reemplazar vamos a pasar a subrayar.
Veamos el resultado.
Te elijan, cambia los espacios por guión bajo.
Ahora, si queremos todo.
Mayúscula K mayúscula reversa, acá reversa y subrayar, acá subrayar.
Perfecto.
Esa es la idea.
Se fijan si leemos al revés.
Hola!
Qué tal Andrés en mayúscula reversa.
Convertimos los espacios con guión y subrayados.
4. Característica y al final son poca clase.
Si hubiésemos utilizado la herencia serían alrededor de 16 clases y acá solamente tenemos cuatro decoradores
subrayado, reversa, reemplazar y mayúscula.
Más El padre, nada más.
Continuamos en la siguiente clase.