mode combiné

Mode combiné (Pattern Composite), également connu dans le cadre du schéma global est pour un groupe d'objets similaires comme un seul objet. modèle de combinaison basée sur une structure arborescente de combiner objet qui représente la partie et le niveau global. Ce type de modèles de conception appartiennent modèle structurel, il crée une structure arborescente du groupe cible.

Cette tendance a créé une classe contient son propre groupe d'objets. Cette classe fournit un moyen de modifier le même groupe d'objet.

Nous par les exemples suivants pour illustrer l'utilisation d'une combinaison de modes. Les exemples démontrent la hiérarchie des employés dans une organisation.

introduction

Intention: Composer des objets dans des structures d'arbres pour représenter " une partie - toute« hiérarchie.le mode combiné permet à l'utilisateur d'utiliser un seul objet et compositions d'objets uniformément.

Principalement pour résoudre: Il est un problème de notre arbre, brouillant le concept d'éléments simples et des éléments complexes, le client peut gérer les éléments aussi simples à manipuler des éléments complexes, de sorte que la structure interne du découplage des clients et des éléments complexes.

Quand l'utiliser: 1, l'objet que vous souhaitez représenter une partie - la hiérarchie entière (arbre).2, vous voulez différents utilisateurs d'ignorer la combinaison d'objets avec un seul objet, l'utilisateur sera combiné structure unifiée pour tous les objets.

Comment fixer: les branches et les feuilles pour obtenir une interface unifiée, l'interface est une combinaison de branches internes.

Le code clé: Bois composition interne de l'interface, et contient la liste des attributs internes, qui a mis des composants.

Exemples d'application: 1, expressions arithmétiques , y compris les opérandes, les opérateurs, et l'autre opérande, qui peut être une autre opération de l' arbre de l' opérateur, les opérateurs, et d' autres opérandes.2, JAVA AWT et SWING, pour Button et Checkbox sont des feuilles, arbre de conteneurs branche.

Avantages: 1, le module de haut niveau appels simple.2, le noeud a augmenté la liberté.

Inconvénients: Lorsque vous utilisez le mode de combinaison, ses feuilles et ses branches mettent en œuvre la déclaration de classe, au lieu d'interfaces, en violation de la inversion des dépendances.

Scénarios d' utilisation:une partie, la scène globale, tels que le menu de l' arbre, le fichier, la gestion des dossiers.

Remarque: Lorsque vous définissez une catégorie spécifique.

réalisation

Nous avons unemployédeclasse,la classe est traitée comme une combinaison de la classe modèle.CompositePatternDemo,nous démontrons l'utilisation de la classedes employésde classe pour ajouter une hiérarchie du département et imprime tous les employés.

Etape 1

Créer la classe desemployés,la classe avec une liste d'objetsemployés.

Employee.java

import java.util.ArrayList;
import java.util.List;

public class Employee {
   private String nom;
   dept private String;
   int salaire privé;
   Liste <Employee> subordonnés privés;

   // Constructor Employé public (String name, String dept, int sal) {
      this.name = nom;
      this.dept = dept;
      this.salary = sal;
      subordonnés = new ArrayList <Employé> ();
   }

   public void add (Employee e) {
      subordinates.add (e);
   }

   public void remove (Employee e) {
      subordinates.remove (e);
   }

   Liste publique <Employé> Les getSubordinates () {
     retour subordonnés;
   }

   public String toString () {
      retour ( «Employé: [Nom:" + nom 
      + ", Dept:" + dept + ", salaire:"
      + Salaire + "]");
   }   
}

Etape 2

Utilisez la classe desemployéspour créer et imprimer la hiérarchie des employés.

CompositePatternDemo.java

public class CompositePatternDemo {
   main (String [] args) {public static void
      PDG de l'employé = new Employee ( "John", "PDG", 30000);

      headSales Employee = new Employee ( "Robert", "Head Sales", 20000);

      Employé headMarketing = new Employee ( "Michel", "Head Marketing", 20000);

      clerk1 Employee = new Employee ( "Laura", "Marketing", 10000);
      clerk2 Employee = new Employee ( "Bob", "Marketing", 10000);

      Employé salesExecutive1 = new Employee ( "Richard", "Sales", 10000);
      Employé salesExecutive2 = new Employee ( "Rob", "Sales", 10000);

      CEO.add (headSales);
      CEO.add (headMarketing);

      headSales.add (salesExecutive1);
      headSales.add (salesExecutive2);

      headMarketing.add (clerk1);
      headMarketing.add (clerk2);

      // Imprimer tous les employés de l'organisation System.out.println (CEO); 
      pour (Employé headEmployee: CEO.getSubordinates ()) {
         System.out.println (headEmployee);
         pour (employés des employés: headEmployee.getSubordinates ()) {
            System.out.println (employé);
         }
      }		
   }
}

Etape 3

Vérifiez la sortie.

Employé: [Nom: John, dept: CEO, salaire: 30000]
Employé: [Nom: Robert, dept: Head Sales, salaire: 20000]
Employé: [Nom: Richard, dept: ventes, salaire: 10000]
Employé: [Nom: Rob, dept: ventes, salaire: 10000]
Employé: [Nom: Michel, dept: Responsable Marketing, Salaire: 20000]
Employé: [Nom: Laura, dept: Marketing, salaire: 10000]
Employé: [Nom: Bob, dept: Marketing, salaire: 10000]