Bienvenidos.
Continuamos con el patrón de diseño compost, que es de la categoría estructurales.
También se le conoce como compuesto o compositor y nos permite construir objetos complejos a partir
de otros objetos más simples, pero que tengan en común alguna clase abstracta, alguna interfaz, es
decir, que sean similares o del mismo tipo.
Entonces, la idea o el problema que intenta solucionar es la recursividad, una estructura en forma
de árbol?
Exactamente lo mismo o muy parecido a lo que vimos en la sección anterior recursividad, pero una forma
un poco más organizada con un patrón diseño, una clase abstracta con un método recursivo.
Veamos el ejemplo, pero antes veamos el diagrama de clase.
Acá tenemos la clase genérica abstracta gráfico con el método pintar recursivo y acá tenemos dos partes
tenemos los componentes por ejemplo círculo, cuadrado, triángulo y tenemos un compuesto que va a estar
formado o compuesto por estas clases, por los componentes.
Entonces un grupo de imágenes está compuesto por un triángulo cuadrado o círculo o combinaciones de
éstas, pero también podría estar compuesto por otro grupo de imágenes.
Es decir, un grupo de imágenes está formado por otro grupo de imágenes y a su vez por esto de por los
componentes.
Y acá lo vemos en el grama.
Todos son tipos de gráfico por herencias.
Círculo hereda de gráfico cuadrado también, el triángulo también, pero grupo de imágenes también es
hija de gráfico.
Todos son gráfico y la clase compuesta o compositor contiene una lista de varios elementos del tipo
gráfico.
Está compuesto por varios gráfico, ya sea grupos o individuales se fijan y eso es finalmente recursiva,
como por ejemplo podríamos tener una clase abstracta elemento o componente, una clase abstracta y clases
hijas archivo por ejemplo archivo PDF o archivo excel.
En fin, archivo da lo mismo y el compuesto sería el directorio.
Un directorio está compuesto por archivos.
Esto está perfecto, pero también puede estar compuesto por otro directorio que a su vez tienen archivos
y lo importante que todos sobre describen el método pintar o dibujar.
Acá en gráfico, en el ejemplo no sé de directorio va a tener el método recorrer o mostrar, pero en
forma recursiva tenemos que iterar, recorrer directorio por directorio y mostrando las imágenes de
cada uno y también por supuesto los directorios dentro de directorios.
Bien, estamos en la página de Wikipedia, así que también tenemos la versión en inglés y acá tenemos
un diagrama de clase un poco más estándar, por ejemplo, la clase abstracta componente con el método
recursivo operación, por ejemplo, y acá tenemos el compuesto y el componente LIF sería el componente
y composite el compuesto.
El compuesto o composite va a estar formado por elementos del tipo componente, se fijan acá.
El rombo entonces tiene un arreglo, una lista de tipos componente component.
Pero recuerden el componen pueden ser un LIF o un compuesto o composite con el método operación método
recursivo.
Además, para agregar y eliminar elementos y para obtenerlos hijos la lista.
En nuestro ejemplo el composer va a ser el directorio, el LIF va a ser archivo y ambos son del tipo
componente.
Vamos a verlo.
Vamos a Cerrato derecho cerrar todo.
Vamos a crear un package en patrones.
Con poceta.
Y decorar 2.
Bueno, lo vamos a cerrar acá.
Bien, vamos a crear nuestra clase.
Componente componente una clase abstracta importante con un método abstracto.
Abstract Public va a devolver un string.
Aunque también podría ser un void, pero lo importante que recorra la estructura de árbol del directorio
y vaya mostrando cada elemento, cada directorio o archivo.
Le vamos a llamar mostrar, mostrar.
Perfecto.
Pero también va a tener atributos protected del tipo String nombre.
Además, un constructor.
Generad constructor con el nombre.
Y el método документы?
Generad Geet.
Nombre Bueno, el set no sería necesario porque él lo pasamos por el constructor.
Eso sería nuestra clase abstracta componente.
Pero vamos a tener dos tipos el directorio y el archivo.
Vamos a partir por el archivo new.
Recuerden que ambos heredan de componente.
Stents componente bien implementamos el método.
Mostrar o constructo del padre también con generate.
Constructor?
Bien.
Bueno, el mostrar es super simple porque es un solo archivo, solamente mostramos el nombre nombre.
Nada más.
Veamos cómo sería el directorio.
Bueno, el territorio un poco más complicado vamos a heredar y lo mismo implementamos el método.
Constructor.
Pero además, va a tener una lista del tipo componente elementos hijos, ya que representa el compuesto
privat list de componente.
Hijos importábamos listo de lleba útil bien y en el constructor disputo inicializamos hijos igual New
ArrayList está molesto.
Bien, vamos a implementar el método agregar componente y eliminar componentes son importantes.
Public void add component bien y que recibe un componente componente le vamos a llamarse hijos.
Punto agregar le pasamos.
Sé perfecto.
Bien puede volver void, pero también podría devolver el mismo tipo directorio.
Para que lo podamos encadenar.
Se acuerdan?
Entonces, por ejemplo, acá devolvemos 10.
10 de acá el tipo de retorno sería un directorio.
Bien.
Ahí tenemos el agregar componente.
Faltaría el eliminar.
Public void lo dejamos en void porque elimina de a uno.
Remu componente.
Componente c hijos.
Punto.
Remove.
Y pasamos el objeto c component para quitar de la lista.
Pero recuerden que se puede eliminar por la instancia projeto lo que hace el list por debajo e buscar
objeto por objeto de la lista.
Iba comparando.
Cuando lo encuentre.
Cuando es igual lo elimina.
Por lo tanto, tenemos que implementar el método equals con alguna regla donde el componente porque
componente es lo que se va a eliminar.
Entonces por acá podemos implementar el método equals y si estamos utilizando un set en vez de un list,
acá un set implementamos el Ascot.
Se acuerdan?
Bueno, eso ya lo vimos.
Así que con Ginette lo podemos hacer con el IDE y quarts y asco lo implementamos.
Siguiente Bueno, el método equals va a comprar por nombre.
Entonces cuando el nombre se igual es porque el objeto es considerado igual, idéntico.
El asco también finaliza bien.
Entonces todo método solamente para el remu.
Para poder eliminar de la lista, aunque serían opcionales.
Pero si lo queremos eliminar, lo tenemos que implementar.
Qué más?
Bueno, eso sería.
Ahora continuamos con el método Mostrar el método recursivo.
Devuelve un string.
Entonces vamos a recorrer el árbol completo.
Los directorios podrían utilizar un string builder String builder.
Recuerden que este método mostrar en el objeto compuesto en este caso directorio es el método recursivo
que también se le va a invocar a los hijos.
Lo primero es mostrar el nombre, así que vamos a agregar al Eltren Builder.
El nombre del directorio, entonces nombre, pero también append.
Le vamos a concatenar o agregar un es latch porque digan el nombre del directorio es el DAT, así como
carpeta.
Perfecto.
Luego un salto de línea.
Saltamos una línea para simular un print line para mostrar los elementos hijos, un paquete larch n
bean y luego un for un forillo.
Los elementos hijos son del tipo componente entonces componente hijo 2 punto 10 punto hijos.
La lista ya que te damos.
Bueno, acá tenemos que llamar por cada hijo el método mostrar de forma recursiva ese punto happen y
acá sería hijo.
Punto mostrar punto happen.
Un salto línea.
Y devolvemos el string builder.
Punto String, ese punto String.
Ahora sí que sí.
Ahí lo tenemos.
Ahora lo tenemos que probar con la clase.
Con el método Main.
Ahora el único problema que vamos a tener es que estamos haciendo todos часто línea acá para el directorio
y después por cada hijo.
La idea de que este salto línea está solamente para lo del tipo archivo y no para directorio.
Porque si no lo estaría duplicando directorio acá afuera y solamente para los tipos archivos acá.
Claro, porque después si es un directorio mostrar se vuelve a invocar el mostrar y hace un salto línea
se fijan como hace un salto línea vaquer repitio Bueno, pero igual veámoslo.
Vamos a crear la clase con el método Main con posit.
New Un package.
Ejemplo de acá New Llévatelas, ejemplo Composer, ejemplo compositor OK.
Con el método Main
vamos a crear un directorio doc o raíz.
Nuestro directorio principal new directorio te vamos a llamar.
Documentos
directorio yaba igual new directorio yaba bien llaba punto agregar componente.
Vamos a agregar un archivo cual por ejemplo patrón composite.
Punto doc doc x un cuarto perfecto.
Entonces pruebe un momento.
Tenemos dos directorios y solamente tenemos yaba entre trujillana y dentro el archivo doc.
Patrón con poceta.
Pero vamos a crear otro directorio más que lo vamos a guardar dentro de yaba.
Directorio stream new directorio API stream el API stream otra carpeta tiene stream.
Vamos a agregar un archivo a componente new archivo.
Por ejemplo podría ser stream map.
El operador map punto doc x se fijan estrema un archivo punto doc dentro del directorio stream.
Lo estamos guardando bien, pero qué pasa con el directorio stream?
Lo tenemos que pasar.
Lo tenemos que agregar en el directorio yaba.
Entonces.
Punto add componente y pasamos estría se fijan.
Entonces Yaba contiene ahora el archivo doc pero también el directorio stream.
Acá lo estamos pasando.
Se fija en yaba punto ad component stream y ya a punto de componer el archivo.
Pero a su vez el territorio stream contiene el archivo extrem map y tenemos una profundida, una estructura
de árbol.
Ahora, qué pasa con Yaba?
Este directorio.
Se lo pasamos adhoc, entonces Documentos va a contener el directorio yaba con toda esta estructura.
Doc punto al componente Yaba, pero también al raíz o doc le podrían agregar un par de archivo para
complementar, por ejemplo, un currículo new archivo se ve punto doc x un curriculum vitae.
Además va a tener at componente new archivo, por ejemplo logo, punto jpg, una imagen en la raíz y
listo.
Ahí tenemos la estructura.
Veamos cómo sería entonces Shout.
Recordemos que el método recursivo mostrar devuelve un string doc que sería nuestra carpeta directorio
principal o raíz punto mostrar.
Recuerden que doc acá aparte de todo doc en la raíz doc contiene yaba que a su vez yaba este acá contiene
el archivo patrón con poceta y contiene el directorio stream.
Acá acá estamos agregando que a su vez tiene un archivo extrem map.
Vamos a ver.
Veamos se fijan documentos, contiene yaba, contiene bueno, ya contiene el patrón con posit y a su
vez Yaba contiene el API stream conectÃ archivo.
El documento contiene estos dos archivos, si se fijan, acá se genera un salto línea de más y eso lo
podemos solucionar acá, como explicaba.
Voy a colocar acá el punto y coma y acá con un if if solamente para los tipos que sean archivo.
Entonces si el hijo enestas off de archivo perfecto.
SB Punto happen.
Se fijan entonces solamente si es del tipo archivo elijo y no directorio.
Porque acá estamos haciendo salto línea en directorio solamente si es archivo.
Hacemos un trato línea.
Vamos a ver.
Se fijan que mucho mejor.
Ahora le podríamos dar profundidad.
Niveles?
Bueno, cómo?
Súper simple.
Nos vamos a ir a componente por acá.
Vamos a modificar el método abstracto en la clase tracta componente int nivel muy.
Parecióle que hicimos también en recursividad.
Exactamente lo mismo.
Ahora modificamos el archivo acá.
Int nivel.
De acá le damos el nivel, por ejemplo, vamos a concatenar más un tabulador.
Punto, repito, cuántas veces?
Bueno, según nivel.
Y lo mismo en territorio.
Acá.
Mostrar int nivel antes que nada, vamos a agregar acá al tabulador en el tren Builders, en el constructor
baxa Larch, una thé punto repite nivel yaca en los hijos sería nivel +1.
Eso es todo.
Solamente faltaría.
Ejemplo Composite y acá sería nivel 0.
Nada más.
Un documento contiene hallaba.
Curriculum vitae y logo, pero ya va.
Contiene el patrón composite Doc API Stream que sube, contiene el archivo Stream Maputo Doc.
Bien, por ahora sería eso muy similar a lo que ya vimos en la sección de recursividad, pero implementado
de forma similar utilizando el patrón composite, usando una clase abstracta y un método recursivo dentro
del componente.
Nos vemos en la siguiente clase.