Definição composta: organize objetos em uma estrutura de árvore para atingir uma hierarquia "total total", para que o cliente tenha uso consistente de objetos individuais e objetos combinados.
O composto é mais fácil de entender. Esses objetos no corpo da composição têm uma interface comum. Pode ser descrito como puxando cem movimentos.
Portanto, o modo composto usa o modo iterador, que é semelhante à cadeia do modo de responsabilidade.
Benefícios compostos:
1. Simplifique o cliente e o cliente pode usar uma estrutura de combinação ou um único objeto de maneira consistente. código.
2. É mais fácil adicionar peças de objeto ao corpo combinado. O cliente não precisa alterar o código porque adicionou um novo componente de objeto.
Como usar composto
Primeiro, defina uma interface ou classe abstrata. Gerenciando composições compostas.
O código a seguir é definido como uma classe abstrata e geralmente tenta usar a interface o máximo possível.
A cópia do código é a seguinte:
Equipamento de classe abstrata pública {
nome de string privado;
// Preço da Internet
Resumo public Double NetPrice ();
// Preço de desconto
Resumo do Public Double DiscountPrice ();
// Adicione o método de peças
public boolean add (equipamento) {return false;
// Excluir método de peça
Public boolean Remover (equipamento) {return false;
// Observe aqui, aqui está um método para acessar classes de componentes.
public iterator iter () {return null;
Equipamento público (nome da string final) {this.name = nome;
}
O equipamento de classe abstrato é a definição de componente, representando os objetos da classe composta, e vários métodos comuns são definidos no equipamento.
A cópia do código é a seguinte:
classe pública Disk estende o equipamento {
Public Disk (Nome da String) {Super (Nome);
// Defina o preço da rede de disco para 1
public Double NetPrice () {Return 1.;
// Defina o preço de desconto do disco é de 0,5% de desconto.
public Double DiscountPrice () {return .5;
}
O disco é um objeto, ou um componente, no corpo combinado, que é um único elemento (primitivo).
Outra possibilidade é que um componente também seja uma combinação, ou seja, existe um 'filho' sob esse componente. Agora precisamos definir esta combinação:
A cópia do código é a seguinte:
Classe abstrata CompositeEquipment estende o equipamento {
privado int i = 0;
// define um vetor para armazenar 'filho'
Equipamento privado LSIT = new ArrayList ();
public compositEEQUIP (Nome da String) {Super (Nome);
public boolean add (equipamento de equipamento) {
this.EQuipment.Add (Equipment);
retornar true;
}
public Double NetPrice () {
NetPrice duplo = 0.;
Iterator iter = Equipment.iterator ();
for (iter.hasnext ())
netPrice+= ((equipamento) iter.Next ()). netPrice ();
Retornar NetPrice;
}
public Double DognPrice () {
Double DiscountPrice = 0.;
Iterator iter = Equipment.iterator ();
for (iter.hasnext ())
descontoPrice+= ((equipamento) iter.Next ()). DOLGPRICE ();
Retornar desconto de desconto;
}
// Observe aqui, aqui está um método para acessar componentes em sua própria combinação.
// O motivo pelo qual o disco acima não existe é porque o disco é um único elemento.
public iterator iter () {
Return Equipment.iterator ();
}
// sobrecarregar o método do iterador
public boolean hasNext () {return i <equipamento.size ();
// sobrecarregar o método do iterador
objeto público a seguir () {
if (hasNext ())
retorno equipamento.Elementat (i ++);
outro
lançar novos nosuchElementException ();
}
}
O CompositeEquipment acima herda o equipamento e fornece métodos de acesso externo para os objetos dentro dele, sobrecarregando o iterador.
Vamos dar uma olhada nas duas categorias específicas de compósito: chassi da caixa de disco e gabinete de caixa. caixa, como unidade de disquete de disco rígido, etc. Sem dúvida, ambos são de combinação.
A cópia do código é a seguinte:
classe pública Chassis estende o ComposetEEQUIPE {
Chassi público (nome da string) {super (nome);
public Double NetPrice () {return 1.+super.netPrice ();
public Double DiscountPrice () {return .5+super.discountPrice ();
}
A classe pública Gabinet estende o CompositeEquipment {
gabinete público (nome da string) {super (nome);
public Double NetPrice () {return 1.+super.netPrice ();
public Double DiscountPrice () {return .5+super.discountPrice ();
}
Até agora, concluímos a arquitetura de todo o modelo composto.
Podemos olhar para o código do cliente chamando compor:
A cópia do código é a seguinte:
Gabinete do gabinete = novo gabinete ("torre");
Chassi chassi = novo chassi ("pc chassi");
// Insira o chassi do PC na torre (embale o disco na caixa)
gabinet.add (chassi);
// Insira um disco rígido de 10 GB no chassi do PC (instale o disco rígido na caixa de disco)
chassis.add (novo disco ("10 GB"));
// chamando o método NetPrice ();
System.out.println ("netPrice ="+Cabinet.netPrice ());
System.out.println ("descontprice ="+Cabinet.DiscountPrice ());
Os métodos chamados acima são NetPrice () ou desconto ().
O composto é um modelo muito inteligente que incorpora a sabedoria.
Tomando o fórum como exemplo, existem muitas postagens (mensagens) em uma versão (fórum). , então entramos Jive, dê uma olhada em como ele é implementado.
Anatomia de Jive
Em Jive, o Forumthread é um contêiner (combinação) de forumessages. Ou seja, o Forumthread é semelhante ao Equipamento Composite em nosso exemplo anterior.
A cópia do código é a seguinte:
[fio]
|- [Mensagem]
|- [Mensagem]
|- [Mensagem]
|- [Mensagem]
|- [Mensagem]
Vemos o seguinte código no Forumthread:
A cópia do código é a seguinte:
Public Interface Forumthread {
....
public void addmessage (forumssage parentmessage, forummessage newmessage)
lança UNAuthorizedException;
Public Void DeleteMessage (Mensagem de Forummessage)
lança UNAuthorizedException;
mensagens de iterador público ();
....
}
Semelhante ao Equipamento composto, ele fornece métodos para acessar componentes em seu próprio corpo de combinação: adicionando, excluindo e atravessando.
Com base na minha análise de Jive em outros modelos, basicamente entendemos a estrutura do sistema de fórum Jive. .