modalità combinata

modalità combinata (composite), noto anche come parte del modello generale è per un gruppo di oggetti simili a quelli di un singolo oggetto. Reticolo Combinazione basato su una struttura ad albero per combinare oggetto che rappresenta la parte e il livello generale. Questo tipo di modelli di progettazione appartengono modello strutturale, crea una struttura ad albero del gruppo target.

Questo modello ha creato una classe contiene un proprio gruppo di oggetti. Questa classe fornisce un modo per modificare stesso gruppo oggetto.

Abbiamo dai seguenti esempi per illustrare l'utilizzo di una combinazione di modi. Esempi dimostrano la gerarchia dei dipendenti di un'organizzazione.

introduzione

Intento: Comporre oggetti in strutture ad albero per rappresentare "parte - tutto" gerarchia.modalità combinata consente all'utente di utilizzare un singolo oggetto e composizioni di oggetti uniformemente.

Principalmente per risolvere: È un problema del nostro albero, confondendo il concetto di elementi semplici e elementi complessi, il client può gestire gli elementi di semplice da gestire elementi complessi, in modo che la struttura interna del disaccoppiamento degli client e elementi complessi.

Quando usare: 1, l'oggetto che si desidera rappresentare parte - tutta la gerarchia (albero).2, si vuole diversi utenti di ignorare la combinazione di oggetti con un singolo oggetto, l'utente sarà abbinata struttura unificata per tutti gli oggetti.

Come risolvere: i rami e le foglie per realizzare un'interfaccia unificata, l'interfaccia è una combinazione di rami interni.

Il codice chiave: legno composizione interna dell'interfaccia, e contiene Lista attributi interni, che ha messo Component.

Esempi di applicazione: 1, espressioni aritmetiche tra operandi, operatori, e l'altro operando, che può essere un'altra operazione albero operatore, operatori, e altro operando.2, JAVA AWT e Swing, per Button e Casella sono le foglie, ramo di un albero Container.

Vantaggi: 1, modulo di alto livello chiamate semplice.2, nodo di una maggiore libertà.

Contro: Quando si utilizza la modalità di combinazione, le sue foglie e rami stanno attuando dichiarazione di classe, invece di interfacce, in violazione del principio di inversione delle dipendenze.

scenari di utilizzo: parte, la scena complessiva, come menu ad albero, di file, gestione delle cartelle.

Nota: Quando si definisce una categoria specifica.

realizzazione

Abbiamo undipendentediclasse,la classe viene trattata come una combinazione della classe del modello.CompositePatternDemo,dimostriamo l'uso di classe di classeEmployeeper aggiungere una gerarchia reparto e stampe di tutti i dipendenti.

fase 1

Crea classeEmployee,la classe con una lista di oggettidipendenti.

Employee.java

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

public class Employee {
   private String name;
   String reparto privato;
   int stipendio privato;
   List <> per i dipendenti subordinati privati;

   // Costruttore dipendenti pubblici (String name, String reparto, int sal) {
      this.name = nome;
      this.dept = reparto;
      this.salary = sal;
      subordinati = new ArrayList <Employee> ();
   }

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

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

   Elenco pubblico <Employee> getSubordinates () {
     tornare subordinati;
   }

   Public String toString () {
      ritorno ( "Impiegato: [Nome:" + nome 
      + ", Dept:" + dept + ", lo stipendio:"
      + Salary + "]");
   }   
}

fase 2

Utilizzare la classedei dipendentiper creare e stampare la gerarchia dei dipendenti.

CompositePatternDemo.java

public class CompositePatternDemo {
   Main (string [] args) {public static void
      CEO Employee = new Employee ( "John", "CEO", 30000);

      headSales dipendenti = nuovo dipendente ( "Robert", "Head vendite", 20000);

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

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

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

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

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

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

      // Stampa tutti i dipendenti System.out.println dell'organizzazione (CEO); 
      for (Employee headEmployee: CEO.getSubordinates ()) {
         System.out.println (headEmployee);
         per (dipendenti dei dipendenti: headEmployee.getSubordinates ()) {
            System.out.println (dipendente);
         }
      }		
   }
}

fase 3

Verifica uscita.

Impiegato: [Nome: John, dept: CEO, stipendio: 30000]
Impiegato: [Nome: Robert, dept: Responsabile vendite, stipendio: 20000]
Impiegato: [Nome: Richard, dept: vendite, stipendio: 10000]
Impiegato: [Nome: Rob, dept: vendite, stipendio: 10000]
Impiegato: [Nome: Michel, dept: Responsabile Marketing, stipendio: 20000]
Impiegato: [Nome: Laura, dept: Marketing, stipendio: 10000]
Impiegato: [Nome: Bob, dept: Marketing, stipendio: 10000]