Patron Composite

Le patron Composite, également appelé patron Partie-Tout, est utilisé pour traiter un groupe d'objets similaires comme un seul objet. Le patron Composite combine les objets selon une structure arborescente afin de représenter des hiérarchies partie-tout. Ce type de patron de conception est un patron structurel ; il crée une structure arborescente de groupes d'objets.

Ce patron crée une classe qui contient un groupe de ses propres objets. La classe fournit un moyen de modifier le même groupe d'objets.

Nous utilisons l'exemple suivant pour démontrer l'utilisation du patron Composite. L'exemple illustre la structure hiérarchique des employés dans une organisation.

Introduction

intention

Combinez des objets en structures arborescentes pour représenter des hiérarchies « partie-tout ». Le patron Composite rend cohérente pour les utilisateurs l'utilisation d'objets individuels et d'objets composites.

Principaux problèmes résolus

  • Simplifiez la gestion des objets dans une structure arborescente, qu'il s'agisse d'objets individuels ou d'objets composites.
  • Découplez le code client de la structure interne des éléments complexes, afin que les clients puissent gérer tous les types de nœuds de manière uniforme.

Cas d'utilisation

  • Lorsqu'il est nécessaire de représenter des structures hiérarchiques d'objets, telles que des systèmes de fichiers ou des structures organisationnelles.
  • Lorsque vous souhaitez que le code client gère tous les objets d'une structure arborescente de manière cohérente.

Approche d'implémentation

  • Interface uniformeDéfinir une interface que tous les objets (branches et feuilles) implémentent.
  • Structure compositeLes objets Branch contiennent une liste de références vers l'interface ; ces références peuvent être des feuilles ou des branches.

Code clé

  • Interface ComponentDéfinir les opérations que tous les objets doivent implémenter.
  • Classe feuilleImplémenter l'interface Component et représenter les nœuds feuilles dans l'arbre.
  • Classe CompositeImplémenter également l'interface Component et contenir une collection d'autres objets Component.

Exemple d'application

  1. Expression arithmétiqueConstruire une structure arborescente composée d'opérandes, d'opérateurs et de sous-expressions.
  2. Composants GUIDans les bibliothèques AWT et Swing de Java, les conteneurs (tels que Panel) peuvent contenir d'autres composants (tels que des boutons et des cases à cocher).

Avantages

  1. Simplifier le code clientLes clients peuvent gérer tous les types de nœuds de manière uniforme.
  2. Facile à étendreDe nouveaux types de feuilles ou de branches peuvent être ajoutés facilement.

Inconvénients

  • Violation du principe d'inversion des dépendancesLes déclarations de Component sont basées sur des classes concrètes plutôt que sur des interfaces, ce qui peut réduire la flexibilité du code.

Suggestions d'utilisation

  • Lors de la conception, préférez les interfaces aux classes concrètes pour améliorer la flexibilité et la maintenabilité du système.
  • Adapté aux scénarios qui nécessitent de gérer des structures arborescentes complexes, telles que les systèmes de fichiers, les structures organisationnelles, etc.

Notes

  • Lors de l'implémentation, assurez-vous que tous les composants suivent une interface unifiée pour maintenir la cohérence.
  • Envisagez d'utiliser le patron de conception Factory pour créer différents types de composants, afin de découpler davantage la logique de création des composants.

Structure

Les rôles principaux du patron Composite incluent :

  • Composant :

    • Définit une interface commune pour tous les objets de la composition, qui peut être une classe abstraite ou une interface. Il déclare des méthodes pour accéder aux composants enfants et les gérer, notamment l'ajout, la suppression et l'obtention des composants enfants, etc.
  • Nœud feuille (Leaf) :

    • Représente les objets nœuds feuilles dans la composition ; les nœuds feuilles n'ont pas d'enfants. Il implémente les méthodes de l'interface Component mais ne contient généralement pas de composants enfants.
  • Nœud composite (Composite) :

    • Représente les objets composites dans la composition. Les nœuds composites peuvent contenir des nœuds enfants, qui peuvent être des nœuds feuilles ou d'autres nœuds composites. Il implémente les méthodes de l'interface Component, y compris les méthodes de gestion des composants enfants.
  • Client :

    • Interagit avec la structure composite via l'interface Component. Les clients n'ont pas besoin de distinguer les nœuds feuilles des nœuds composites et peuvent traiter les ensembles et les parties de manière cohérente.

Implémentation

Nous avons une classeEmployee, cette classe est traitée comme la classe de modèle composite.CompositePatternDemoUtilisation de la classeEmployeeClasse pour ajouter la hiérarchie des départements et afficher tous les employés.

组合模式的 UML 图

Étape 1

Créez la classeEmployee, qui possède une liste d'objetsEmployee.

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; //Constructeur 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 ("Employé :[ Nom : "+ name +", département : "+ dept + ", salaire :" + salary+" ]"); } }

Étape 2

UtilisationEmployeeClasse pour créer et imprimer la hiérarchie des employés.

CompositePatternDemo.java

public class CompositePatternDemo { public static void main(String[] args) { Employee CEO = new Employee("John","CEO", 30000); Employee headSales = new Employee("Robert","Chef des ventes", 20000); Employee headMarketing = new Employee("Michel","Chef du 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); //Afficher tous les employés de l'organisation System.out.println(CEO); for (Employee headEmployee : CEO.getSubordinates()) { System.out.println(headEmployee); for (Employee employee : headEmployee.getSubordinates()) { System.out.println(employee); } } } }

Étape 3

Exécutez le programme, la sortie est :

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 ]
autres extensions