Definição do visitante: uma operação que age em cada objeto em um determinado grupo de objetos. Ele permite definir novas operações que agem sobre esses objetos sem alterá -los.
Em Java, o padrão do visitante realmente separa elementos na estrutura de coleta e o comportamento de operar nesses elementos.
Por que usar o modo de visitante
A coleção Java (incluindo vetor e hashtable) é a tecnologia que usamos com mais frequência, mas a coleção parece ser um grande tingimento preto IVA. Então devemos usar se para julgar, como:
A cópia do código é a seguinte:
Iterator iterator = collection.iterator ()
while (iterator.hasnext ()) {
Objeto o = iterator.Next ();
if (o exemploof coleção)
MessyPrintCollection ((coleção) o);
else if (o instanceof string)
System.out.println ("'"+o.toString ()+"'");
caso contrário, se (o instanceof flutuar)
System.out.println (O.ToString ()+"F");
outro
System.out.println (O.ToString ());
}
No exemplo acima, usamos a instância para determinar o tipo de o.
Obviamente, as desvantagens de fazer isso, se o código for pesado, podemos resolvê -lo usando o modo de visitante.
Como usar o modo de visitante
Para o exemplo acima, projetamos um visitante de interface Visitor:
A cópia do código é a seguinte:
Visitante de interface pública
{
Public Void VisitCollection (coleção);
public void visitString (string string);
public void visitfloat (flutuação flutuante);
}
Nesta interface, coloque os tipos de classes que achamos que a coleção é possível.
Com os visitantes, precisamos ser visitados. Não o recebe, o visitante não poderá visitar).
Definimos essa interface como visível, que é definir uma operação de aceitação, ou seja, tornar cada elemento da coleção acessível.
A cópia do código é a seguinte:
interface pública visitável {
Public Void aceita (visitante visitante);
}
OK, com duas interfaces, precisamos definir sua implementação específica (classe concreta):
A cópia do código é a seguinte:
Public Class ConcreteElement Iplementos Visitable
{
Valor de String Private;
public concreteElement (string string) {
value = string;
}
// Definir o conteúdo específico da aceitação aqui é uma frase muito simples para chamar public void Acep (visitante visitante) {
visitor.visitString (isto);
}
}
Vamos dar uma olhada na implementação concreta do visitante:
A cópia do código é a seguinte:
Classe pública ConcreteVisitor implementa visitante
{
// Neste método, implementamos acesso bem -sucedido aos elementos da coleção Public Void VisitCollection (coleção) {
Iterator iterator = collection.iterator ()
while (iterator.hasnext ()) {
Objeto o = iterator.Next ();
se (o instância de visitável)
((Visitável) o) .cecept (isto);
}
public void visitstring (string string) {
System.out.println ("'"+string+"'");
}
public void visitfloat (flutuador) {
System.out.println (float.toString ()+"f");
}
}
No visitCollection acima, implementamos o acesso a cada elemento da coleção, usando apenas uma declaração de julgamento, apenas para determinar se é acessível.
Nesse ponto, concluímos a arquitetura básica do modelo de visitante.
Pré -requisitos para usar o modo de visitante
O tipo de objeto na estrutura do grupo de objetos raramente é alterado, ou seja, o tipo de identidade do visitante raramente é alterado, como o tipo de visitante acima raramente é alterado, se forem necessárias novas operações, como no exemplo acima, nós, nós Além da implementação específica do concreto, também é necessário o novo concreto de concreto2 ConcreteElement3.
Pode -se observar que há um pré -requisito para usar o modo de visitante.
Se o visitante também mudar com frequência, ou seja, os tipos de objetos no grupo de objetos geralmente mudam, a sugestão geral é que é melhor definir as operações uma a uma nessas classes de objetos, mas a tecnologia reflete de Java resolve esse problema.