Dê um exemplo para explicar a aplicação do modo de visitante no modo de design na programação Java

Modo do visitante: encapsula algumas operações que atuam em cada elemento em uma determinada estrutura de dados. Ele pode definir novas operações que agem sobre esses elementos sem alterar essa estrutura de dados. O diagrama de estrutura do modo de visitante é o seguinte:

Na foto acima, você pode ver que ele tem os seguintes personagens:
Abstrato Função do visitante: define uma interface e declara uma ou mais operações de acesso.
Função do visitante concreto: implementa a interface declarada por visitantes abstratos, ou seja, as várias operações de acesso declaradas por visitantes abstratos.
Função do elemento resumo (visitável): declara uma operação de aceitação, aceitando um objeto de visitante como um parâmetro.
Função de concreto: implementa a operação de aceitação especificada por nós abstratos.
Função do objeto de estrutura de dados (ObjectStructure): pode atravessar todos os elementos da estrutura e fornecer uma interface para o objeto do visitante acessar cada elemento.
O código de simulação é o seguinte:

 Visitante da interface {VIST VIST (Gladiolus g); visita vazia (crisântemo c); }

 // Classe de acesso ao visitante de concreto StringVisitor implementa o visitante {string s; public string tostring () {return s; } public void visit (gladiolus g) {s = "gladiolus"; } public void Visit (Chrysanteumum c) {s = "Chrysanteumum"; }}

 // classe de visitante concreto beevisitor implementa o visitante {public void visit (gladiolus g) {System.out.println ("Bee to Access Gladiolus"); } public void visit (Chrysanteum c) {System.out.println ("Bee to Access Chrysanteum"); }}

 Flor da interface {Void aceita (Visitante V); }

 / * * Elemento concreto Crisântemo implementa a flor {public void aceit (visitante v) {v.Visit (this); }}

 // Classe de elemento concreto Gladiolus implementa a flor {public void aceit (visitante v) {v.Visit (this); }}

 // Esta é uma classe de gerador de objeto de flores FlowerGenerator {private estático rand aleatório = novo aleatório (); public static flor newflower () {switch (rand.nextInt (2)) {padrão: case 0: return new gladiolus (); Caso 1: Retorne Novo Crisântemo (); }}}

 Public class Test { / * * Primeiro, obtenha uma função de visitante específica no cliente. A estrutura do objeto é atravessada. Chame o método de aceitação para cada elemento e passe a função específica do visitante. Isso completa todo o processo*/ public static void main (string args []) {list <flower> flores = novo ArrayList <Flor> (); for (int i = 0; i <10; i ++) flores.add (florgenerator.newflower ()); Visitante visitante = new stringVisitor (); Iterador <Flower> iterator = flores.iterator (); while (iterator.hasnext ()) {iterator.Next (). Acep (visitante); System.out.println (visitante); } System.out.println ("-----------------------"); /** Um novo comportamento de acesso: Beevisitor Bee Access*/ visitante visitante2 = new BeEvisitor (); para (Flor Flor: Flores) {Flower.Ecept (Visitor2); }}}

resultado:

 Gladiolus crisântemo crisântemo gladíolo chrysanthemum chrysanthemum crisântemo chrysanthemum gladioteliolus gladio -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

O modo de visitante pode ser considerado se:

1. Uma estrutura de objeto contém muitos objetos de classe e eles têm interfaces diferentes e você deseja implementar algumas operações que dependem de suas classes específicas desses objetos.
2. Você precisa executar muitas operações diferentes e irrelevantes em objetos em uma estrutura de objeto e deseja evitar deixar essas operações "poluir" as classes desses objetos. O visitante permite concentrar operações relacionadas e defini -las em uma classe.
3. Quando a estrutura do objeto for compartilhada por muitos aplicativos, use o modo de visitante para permitir que cada aplicativo contenha apenas as operações que precisam ser usadas.
4. As classes que definem a estrutura do objeto raramente mudam, mas são necessárias novas operações para definir essa estrutura. Alterar a classe de estrutura do objeto requer redefinir a interface para todos os visitantes, o que pode ser um grande custo. Se a classe de estrutura do objeto mudar com frequência, pode ser melhor definir essas operações nessas classes.
Esses indivíduos parecem ser sugestões, e questões específicas precisam ser analisadas no projeto.