modo combinado

modo combinado (Composite Pattern), também conhecido como parte do padrão geral é para um grupo de objetos similares como um único objeto. padrão de combinação com base em uma estrutura de árvore para combinar objeto que representa a parte e ao nível global. Este tipo de padrões de projeto pertencem modelo estrutural, ele cria uma estrutura de árvore do grupo-alvo.

Este padrão criado uma classe contém o seu próprio grupo de objetos. Essa classe fornece uma maneira de modificar o mesmo objeto grupo.

Nós pelos exemplos seguintes para demonstrar o uso de uma combinação de modos. Exemplos demonstram a hierarquia dos funcionários em uma organização.

introdução

Intenção: Compor objetos em estruturas de árvore para representar "parte - todo" hierarquia.Modo combinado permite que o usuário usar um único objeto e composições de objetos de maneira uniforme.

Principalmente para resolver: É um problema da nossa árvore, esbater o conceito de elementos simples e elementos do complexo, o cliente pode manipular os elementos tão simples de manipular elementos complexos, de modo que a estrutura interna da dissociação entre o cliente e elementos complexos.

Quando usar: 1, o objeto que você deseja representar parte - hierarquia inteira (árvore).2, você quer que diferentes usuários a ignorar a combinação de objetos com um único objeto, o usuário será combinada estrutura unificada para todos os objetos.

Como corrigir: os ramos e folhas para alcançar interface unificada, a interface é uma combinação de ramos internos.

O código-chave: composição interna de madeira da interface, e contém lista de atributos internos, o que colocou Component.

Exemplos de aplicação: 1, expressões aritméticas incluindo operandos, operadores e o outro operando, que pode ser uma outra operação árvore operador, operadores, e outro operando.2, JAVA AWT e swing, para Button e Caixa de seleção são as folhas, ramo de árvore Container.

Vantagens: 1, módulo de alto nível chama simples.2, o nó maior liberdade.

Contras: Ao utilizar o modo de combinação, suas folhas e ramos estão implementando declaração da classe, em vez de interfaces, em violação do princípio de inversão de dependência.

cenários de uso: parte, a cena global, como menu de árvore, arquivos, gerenciamento de pasta.

Nota: Quando você define uma categoria específica.

realização

Temos umempregado classe,a classe é tratada como uma combinação da classe model.CompositePatternDemo,demonstramos o uso de classe classe defuncionáriospara adicionar uma hierarquia de departamentos e imprime todos os funcionários.

passo 1

Criar classe defuncionários,a classe com uma lista de objetosEmployee.

Employee.java

importação java.util.ArrayList;
import java.util.List;

Employee classe pública {
   private String nome;
   dept private String;
   salário int privado;
   List <Employee> subordinados privadas;

   // Construtor Funcionário público (String nome, String dept, int sal) {
      this.name = nome;
      this.dept = dept;
      this.salary = sal;
      subordinados = new ArrayList <Employee> ();
   }

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

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

   Lista pública <Employee> getSubordinates () {
     voltar subordinados;
   }

   public String toString () {
      return ( "Employee: [nome:" + nome 
      + ", Dept:" + departamento + ", salário:"
      + Salário + "]");
   }   
}

passo 2

Use classe defuncionáriospara criar e imprimir a hierarquia dos funcionários.

CompositePatternDemo.java

CompositePatternDemo classe pública {
   main (String [] args) public static void {
      CEO empregado = new Employee ( "John", "CEO", 30000);

      headSales Funcionário = novo funcionário ( "Robert", "Cabeça de Vendas", 20000);

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

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

      Empregado salesExecutive1 = new Employee ( "Richard", "Vendas", 10000);
      Empregado salesExecutive2 = new Employee ( "Rob", "Vendas", 10000);

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

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

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

      // Impressão todos os funcionários System.out.println da organização (CEO); 
      for (Employee headEmployee: CEO.getSubordinates ()) {
         System.out.println (headEmployee);
         para (empregado empregado: headEmployee.getSubordinates ()) {
            System.out.println (empregado);
         }
      }		
   }
}

passo 3

Verifique saída.

Funcionário: [Nome: John, dept: CEO, salário: 30000]
Funcionário: [Nome: Robert, dept: Cabeça de vendas, salário: 20000]
Funcionário: [Nome: Richard, departamento: Vendas, salário: 10000]
Funcionário: [Nome: Rob, departamento: Vendas, salário: 10000]
Funcionário: [Nome: Michel, departamento: marketing Head, salário: 20000]
Funcionário: [Nome: Laura, dept: Marketing, salário: 10000]
Funcionário: [Nome: Bob, dept: Marketing, salário: 10000]