Patrón de Composite

El patrón de Composite (Composite Pattern), también llamado patrón de parte-todo, se utiliza para tratar un grupo de objetos similares como un solo objeto. El patrón de Composite combina objetos según una estructura de árbol para representar jerarquías de parte y todo. Este tipo de patrón de diseño pertenece a los patrones estructurales, y crea una estructura de árbol de grupos de objetos.

Este patrón crea una clase que contiene su propio grupo de objetos. Dicha clase proporciona una forma de modificar el mismo grupo de objetos.

Demostramos el uso del patrón de Composite mediante el siguiente ejemplo. El ejemplo muestra la jerarquía de empleados en una organización.

Introducción

Intención

Combinar objetos en una estructura de árbol para representar jerarquías de "parte-todo". El patrón de Composite permite que los usuarios traten de manera consistente tanto a objetos individuales como a objetos compuestos.

Problemas principales que resuelve

  • Simplifica el manejo de objetos en una estructura de árbol, ya sean objetos individuales o compuestos.
  • Desacopla el código del cliente de la estructura interna de elementos complejos, permitiendo que el cliente procese uniformemente todos los tipos de nodos.

Escenarios de uso

  • Cuando se necesita representar una jerarquía de objetos, como un sistema de archivos o una estructura organizativa.
  • Cuando se desea que el código del cliente pueda manejar todos los objetos de la estructura de árbol de manera consistente.

Método de implementación

  • Interfaz unificada: define una interfaz que todos los objetos (ramas y hojas) implementan.
  • Estructura compuesta: el objeto rama contiene una lista de referencias a la interfaz; estas referencias pueden ser hojas o ramas.

Código clave

  • Interfaz Component: define las operaciones que todos los objetos deben implementar.
  • Clase Leaf: implementa la interfaz Component y representa nodos hoja en el árbol.
  • Clase Composite: también implementa la interfaz Component y contiene una colección de otros objetos Component.

Ejemplos de aplicación

  1. Expresión aritmética: construye una estructura de árbol compuesta por operandos, operadores y subexpresiones.
  2. Componentes GUI: en las bibliotecas AWT y Swing de Java, los contenedores (como Panel) pueden contener otros componentes (como botones y casillas de verificación).

Ventajas

  1. Simplifica el código del cliente: el cliente puede manejar uniformemente todos los tipos de nodos.
  2. Fácil de extender: se pueden agregar fácilmente nuevos tipos de hojas o ramas.

Desventajas

  • Viola el principio de inversión de dependencias: la declaración de componentes se basa en clases concretas en lugar de interfaces, lo que puede reducir la flexibilidad del código.

Recomendaciones de uso

  • Al diseñar, priorice el uso de interfaces en lugar de clases concretas para mejorar la flexibilidad y mantenibilidad del sistema.
  • Es adecuado para escenarios que requieren manejar estructuras de árbol complejas, como sistemas de archivos, estructuras organizativas, etc.

Precauciones

  • Al implementar, asegúrese de que todos los componentes sigan una interfaz unificada para mantener la consistencia.
  • Considere usar el patrón de fábrica para crear diferentes tipos de componentes, para desacoplar aún más la lógica de creación de componentes.

Estructura

Los roles principales del patrón de Composite incluyen:

  • Componente (Component):

    • Define la interfaz común para todos los objetos en la composición; puede ser una clase abstracta o una interfaz. Declara métodos para acceder y gestionar subcomponentes, incluyendo agregar, eliminar, obtener subcomponentes, etc.
  • Nodo hoja (Leaf):

    • Representa el objeto de nodo hoja en la composición; el nodo hoja no tiene subnodos. Implementa los métodos de la interfaz de componente, pero generalmente no contiene subcomponentes.
  • Nodo compuesto (Composite):

    • Representa el objeto compuesto en la composición; el nodo compuesto puede contener subnodos, que pueden ser nodos hoja u otros nodos compuestos. Implementa los métodos de la interfaz de componente, incluidos los métodos para gestionar subcomponentes.
  • Cliente (Client):

    • Interactúa con la estructura compuesta a través de la interfaz de componente. El cliente no necesita distinguir entre nodos hoja y nodos compuestos, y puede tratar el todo y las partes de manera consistente.

Implementación

Tenemos una claseEmployee, que se utiliza como clase de modelo compuesto.CompositePatternDemoLa clase usaEmployeela clase para agregar la jerarquía de departamentos e imprimir todos los empleados.

组合模式的 UML 图

Paso 1

CrearEmployeela clase, que tiene una lista deEmployeeobjetos.

Employee.java

import java.util.ArrayList; import java.util.List; public class Employee { private String name; private String dept; private int salary; private List<Employee> subordinates; //Constructor public Employee(String name,String dept, int sal) { this.name = name; this.dept = dept; this.salary = sal; subordinates = new ArrayList<Employee>(); } public void add(Employee e) { subordinates.add(e); } public void remove(Employee e) { subordinates.remove(e); } public List<Employee> getSubordinates(){ return subordinates; } public String toString(){ return ("Employee :[ Name : "+ name +", dept : "+ dept + ", salary :" + salary+" ]"); } }

Paso 2

UsarEmployeela clase para crear e imprimir la jerarquía de empleados.

CompositePatternDemo.java

public class CompositePatternDemo { public static void main(String[] args) { Employee CEO = new Employee("John","CEO", 30000); Employee headSales = new Employee("Robert","Head Sales", 20000); Employee headMarketing = new Employee("Michel","Head Marketing", 20000); Employee clerk1 = new Employee("Laura","Marketing", 10000); Employee clerk2 = new Employee("Bob","Marketing", 10000); Employee salesExecutive1 = new Employee("Richard","Sales", 10000); Employee salesExecutive2 = new Employee("Rob","Sales", 10000); CEO.add(headSales); CEO.add(headMarketing); headSales.add(salesExecutive1); headSales.add(salesExecutive2); headMarketing.add(clerk1); headMarketing.add(clerk2); //Imprimir todos los empleados de la organización System.out.println(CEO); for (Employee headEmployee : CEO.getSubordinates()) { System.out.println(headEmployee); for (Employee employee : headEmployee.getSubordinates()) { System.out.println(employee); } } } }

Paso 3

Ejecutar el programa; el resultado es:

Employee :[ Name : John, dept : CEO, salary :30000 ]
Employee :[ Name : Robert, dept : Head Sales, salary :20000 ]
Employee :[ Name : Richard, dept : Sales, salary :10000 ]
Employee :[ Name : Rob, dept : Sales, salary :10000 ]
Employee :[ Name : Michel, dept : Head Marketing, salary :20000 ]
Employee :[ Name : Laura, dept : Marketing, salary :10000 ]
Employee :[ Name : Bob, dept : Marketing, salary :10000 ]
Otras extensiones