El patrón compuesto consiste en incluir otros objetos dentro de un objeto. Estos objetos incluidos pueden ser objetos terminales (que ya no contienen otros objetos) u objetos no terminales (que internamente contienen otros objetos, también llamados objetos de grupo). Llamamos nodos a estos objetos: es decir, un nodo raíz contiene muchos nodos hijo; algunos de estos nodos hijo ya no contienen nodos hijo, mientras que otros todavía los contienen, y así sucesivamente. Evidentemente, se trata de una estructura de árbol: los nodos terminales se llaman nodos hoja, los nodos no terminales (nodos de grupo) se llaman nodos rama, y el primer nodo se llama nodo raíz. También es similar a la estructura de un directorio de archivos: los archivos pueden denominarse nodos terminales y los directorios pueden denominarse nodos no terminales (nodos de grupo).


Implementación común

1. Primero veamos una implementación común de una estructura de directorio:

Nodo de directorio: Noder

import java.util.ArrayList; import java.util.List; /** * Nodo de directorio * Contiene: * 1. Nombre del directorio * 2. Lista de archivos subordinados * 3. Lista de directorios subordinados * 4. Método para agregar archivos * 5. Método para agregar directorios * 6. Método para mostrar contenido subordinado*/ public class Noder { String nodeName;//Nombre del directorio //Nombrar el directorio a través del constructor public Noder(String nodeName){ this.nodeName = nodeName; } List<Noder> nodeList = new ArrayList<Noder>();//Lista de directorios subordinados del directorio List<Filer> fileList = new ArrayList<Filer>();//Lista de archivos subordinados del directorio //Agregar directorio subordinado public void addNoder(Noder noder){ nodeList.add(noder); } //Agregar archivo public void addFiler(Filer filer){ fileList.add(filer); } //Mostrar directorios y archivos subordinados public void display(){ for(Noder noder:nodeList){ System.out.println(noder.nodeName); noder.display();//Mostrar la lista de directorios de forma recursiva } for(Filer filer:fileList){ filer.display(); } } }

Nodo de archivo: Filer

/** * Nodo de archivo * El nodo de archivo es un nodo terminal, sin nodos subordinados * Contiene: * 1. Nombre del archivo * 2. Método de visualización del archivo*/ public class Filer { String fileName;//Nombre del archivo public Filer(String fileName){ this.fileName = fileName; } //Método de visualización del archivo public void display(){ System.out.println(fileName); } }

Clase de prueba: Clienter

import java.io.File; public class Clienter { public static void createTree(Noder node){ File file = new File(node.nodeName); File[] f = file.listFiles(); for(File fi : f){ if(fi.isFile()){ Filer filer = new Filer(fi.getAbsolutePath()); node.addFiler(filer); } if(fi.isDirectory()){ Noder noder = new Noder(fi.getAbsolutePath()); node.addNoder(noder); createTree(noder);//Usar recursión para generar la estructura de árbol } } } public static void main(String[] args) { Noder noder = new Noder("E://ceshi"); createTree(noder);//Crear la estructura de árbol de directorios noder.display();//Mostrar directorios y archivos } }

Resultado de la ejecución:

E:\ceshi\目录1
E:\ceshi\目录1\目录3
E:\ceshi\目录1\文件2.txt
E:\ceshi\目录2
E:\ceshi\目录2\文件3.txt
E:\ceshi\文件1.txt

2. Patrón compuesto

Como se puede ver en el código anterior, definimos por separado el objeto nodo de archivo y el objeto nodo de directorio. Esto se debe a que las operaciones entre archivo y directorio son diferentes: el archivo no tiene nodos subordinados, mientras que el directorio sí puede tenerlos. Pero, ¿podemos pensarlo de esta manera? Dado que tanto el archivo como el directorio pueden existir como nodos subordinados de un nodo, ¿podemos abstraer ambos en un mismo tipo de objeto? Aunque sus operaciones difieren, podemos definirlas concretamente en la implementación de los métodos de la clase de implementación. Por ejemplo, si el archivo no tiene un método para agregar nodos subordinados, podemos lanzar una excepción en ese método del archivo sin una implementación concreta, mientras que en el directorio implementamos concretamente la operación de agregar. La operación de mostrar existe en ambos y cada uno puede implementarla. Además, al abstraer archivo y directorio en un solo tipo, combinado con el polimorfismo, podemos realizar la siguiente implementación:

Clase abstracta: Node

/** * Considerar archivos y directorios uniformemente como un tipo de nodo; crear una clase abstracta para definir este nodo y luego usar sus clases de implementación para distinguir archivos y directorios, definiendo en cada clase de implementación su contenido específico.*/ public abstract class Node { protected String name;//Nombre //Asignar nombre mediante el constructor public Node(String name){ this.name = name; } //Agregar nodo: el nodo de archivo no tiene este método; el nodo de directorio sobrescribe este método public void addNode(Node node) throws Exception{ throw new Exception("Invalid exception"); } //Mostrar nodo: tanto el archivo como el directorio implementan este método abstract void display(); }

Clase de implementación de archivo: Filter

/** * Implementar el nodo de archivo*/ public class Filer extends Node { //Nombrar el nodo de archivo a través del constructor public Filer(String name) { super(name); } //Mostrar el nodo de archivo @Override public void display() { System.out.println(name); } }

Clase de implementación de directorio: Noder

import java.util.*; /** * Implementar el nodo de directorio*/ public class Noder extends Node { List<Node> nodeList = new ArrayList<Node>();//Lista de nodos internos (incluye archivos y directorios subordinados) //Asignar nombre al nodo de directorio actual a través del constructor public Noder(String name) { super(name); } //Agregar nodo public void addNode(Node node) throws Exception{ nodeList.add(node); } //Mostrar los nodos subordinados de forma recursiva @Override void display() { System.out.println(name); for(Node node:nodeList){ node.display(); } } }

Clase de prueba: Clienter

import java.io.File; public class Clienter { public static void createTree(Node node) throws Exception{ File file = new File(node.name); File[] f = file.listFiles(); for(File fi : f){ if(fi.isFile()){ Filer filer = new Filer(fi.getAbsolutePath()); node.addNode(filer); } if(fi.isDirectory()){ Noder noder = new Noder(fi.getAbsolutePath()); node.addNode(noder); createTree(noder);//Usar recursión para generar la estructura de árbol } } } public static void main(String[] args) { Node noder = new Noder("E://ceshi"); try { createTree(noder); } catch (Exception e) { e.printStackTrace(); } noder.display(); } }

Resultado de salida de la ejecución:

E://ceshi
E:\ceshi\文件1.txt
E:\ceshi\目录1
E:\ceshi\目录1\文件2.txt
E:\ceshi\目录1\目录3
E:\ceshi\目录2
E:\ceshi\目录2\文件3.txt

De la implementación anterior se puede observar que el llamado patrón compuesto en realidad trata el problema de que un objeto contiene objetos. Se realiza la disposición mediante la composición (referenciar objetos dentro de un objeto). Creo que esta composición se distingue de la herencia. Otra capa de significado se refiere a la abstracción de los nodos hijos en una estructura de árbol (abstraer los nodos hoja y los nodos rama como nodos hijos), a diferencia de la forma común de definir por separado los nodos hoja y los nodos rama.


3. Escenarios de aplicación del patrón compuesto

Este patrón compuesto nace precisamente para las estructuras de árbol, por lo que el escenario de uso del patrón compuesto es donde aparece una estructura de árbol. Por ejemplo: visualización de directorios de archivos, presentación de directorios multinivel y otras operaciones sobre datos con estructura de árbol.

Dirección original: https://www.cnblogs.com/V1haoge/p/6489827.html