Mode combinaison

Le motif composite, également appelé motif partie-tout, est utilisé pour traiter un groupe d'objets similaires comme un objet unique. Le mode composition combine les objets selon une structure arborescente, qui est utilisée pour représenter des hiérarchies partielles et entières. Ce type de modèle de conception est un modèle structurel, qui crée une structure arborescente de groupes d’objets.

Ce modèle crée une classe qui contient son propre ensemble d'objets. Cette classe fournit un moyen de modifier des groupes d'objets identiques.

Nous utilisons l'exemple suivant pour démontrer l'utilisation du mode combinaison. L'exemple illustre la hiérarchie des employés dans une organisation.

Introduction

Intention : Combinez des objets dans une structure arborescente pour représenter une hiérarchie « partie-tout ». Le modèle de composition permet aux utilisateurs d'utiliser des objets uniques et des objets composites de manière cohérente.

Solution principale : Cela brouille les concepts d'éléments simples et d'éléments complexes dans notre problème de structure arborescente. Le programme client peut traiter des éléments complexes de la même manière que des éléments simples, créant ainsi des programmes clients. sont découplés de la structure interne des éléments complexes.

Quand utiliser : 1 Vous souhaitez représenter la hiérarchie partie-tout (arborescence) d'un objet. 2. Vous souhaitez que les utilisateurs ignorent la différence entre les objets combinés et les objets uniques, et que les utilisateurs utilisent uniformément tous les objets de la structure combinée.

Comment résoudre : Les branches et les feuilles implémentent une interface unifiée, et l'interface est combinée à l'intérieur de la branche.

Code clé : La branche combine en interne cette interface et contient une liste d'attributs interne, qui contient un composant.

Exemples d'application : 1. Les expressions arithmétiques incluent des opérandes, des opérateurs et un autre opérande, où un autre opérateur peut également être un arbre d'opérations, un opérateur et un autre numéro d'opération. 2. Dans JAVA AWT et SWING, Button et Checkbox sont des feuilles et Container est une branche.

Avantages : 1. Les appels de modules de haut niveau sont simples. 2. Les nœuds peuvent être ajoutés librement.

Inconvénients : Lors de l'utilisation du modèle de combinaison, les déclarations des feuilles et des branches sont des classes d'implémentation, pas des interfaces, ce qui viole le principe d'inversion de dépendance.

Scénarios d'utilisation : Scénarios partiels et globaux, tels que le menu arborescent, la gestion des fichiers et des dossiers.

Remarque : est défini comme une classe concrète.

Implémentation

Nous avons une classe Employé qui est traitée comme une classe modèle composite. CompositePatternDemo, notre classe de démonstration utilise la classe Employee pour ajouter la hiérarchie des départements et imprimer tous les employés.

Étape 1

Créez la classe Employé avec une liste d'objets Employé.

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;

   //构造函数
   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+" ]");
   }   
}

Étape 2

Utilisez la classe Employee 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","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);

      //打印该组织的所有员工
      System.out.println(CEO); 
      for (Employee headEmployee : CEO.getSubordinates()) {
         System.out.println(headEmployee);
         for (Employee employee : headEmployee.getSubordinates()) {
            System.out.println(employee);
         }
      }		
   }
}

Étape 3

Vérifiez la sortie.

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 ]