23 Padrões de design Capítulo 16: Java Visitor Pattern
Definição: encapsula certas 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 a estrutura de dados.
Tipo: padrão comportamental
Diagrama de classe:
O modo de visitante pode ser o modo mais complexo entre os modos comportamentais, mas isso não pode ser uma razão pela qual não o dominamos.
Vamos primeiro olhar para um exemplo simples, o código é o seguinte
classe a {public void method1 () {System.out.println ("eu sou A"); } public void Method2 (b b) {b.showa (this); }} classe b {public void showa (a a) {a.method1 (); }}Vamos analisar principalmente qual é a diferença entre o método1 e o método do método2 na classe A. O método1 é muito simples, basta imprimir uma frase "eu sou um"; O método do método2 é um pouco mais complicado, use a classe B como um parâmetro e chame o método Showa da classe B.
Vamos dar uma olhada no método Showa da classe B. O método Showa usa a classe A como um parâmetro e, em seguida, chama o método do método1 da classe A. Você pode ver que o método Method2 está chamando seu próprio método1. Seu resultado em execução também deve ser "eu sou um". Após a análise, vamos executar esses dois métodos e ver o resultado da execução:
classe pública teste {public static void main (string [] args) {a a = new a (); a.method1 (); a.method2 (novo b ()); }}O resultado em execução é:
Eu sou um
Eu sou um
Depois de entender este exemplo, você entenderá 90% do padrão do visitante. No exemplo, para a classe A, a classe B é um visitante. No entanto, este exemplo não é o modo inteiro do visitante. Embora seja intuitivo, tem baixa escalabilidade. Vamos falar sobre a implementação geral do modo de visitante. Você pode ver através do diagrama de classes que, no modo visitante, as seguintes funções são incluídas principalmente:
Visitante abstrato: Uma classe ou interface abstrata que declara quais elementos o visitante pode acessar. Especificamente no programa, os parâmetros no método de visita definem quais objetos podem ser acessados.
Visitante: Implemente o método declarado por visitantes abstratos, que afeta o que os visitantes devem fazer e o que devem fazer depois de acessar uma aula.
Classe de elemento abstrato: uma interface ou classe abstrata que declara que tipo de acesso ao visitante é aceito. O programa é definido através de parâmetros no método de aceitação. Geralmente, existem dois tipos de métodos para elementos abstratos, um é sua própria lógica de negócios e a outra é qual tipo de visitantes pode acessar.
Classe do elemento: implementa o método de aceitação declarado pela classe de elemento abstrato, geralmente visitante.Visit (isso), e basicamente formou uma fórmula fixa.
Objeto estrutural: um contêiner de elemento geralmente contém um recipiente que acomoda várias classes e interfaces diferentes, como lista, conjunto, mapa etc. Essa função raramente é abstraída no projeto.
Implementação de código comum do modo de visitante
Resumo da classe Element {public abstrate void aceit (visitante ivisitor); public abstrato void dosomething (); } interface IVISITER {public void visit (concreteElement1 el1); Visita pública de vazio (concreteElement2 el2); } classe concreteElement1 estende o elemento {public void dosomething () {System.out.println ("Este é o elemento 1"); } public void aceit (visitante ivisitor) {visitante.visit (this); }} classe concreteElement2 estende o elemento {public void Dosomething () {System.out.println ("Este é o elemento 2"); } public void aceit (visitante ivisitor) {visitante.visit (this); }} classe Visitante implementa o IVISITION {public void visit (concreteElement1 el1) {el1.dosomething (); } public void visit (concreteElement2 el2) {el2.dosomething (); }} classe ObjectStruture {public static list <lement> getList () {list <lement> list = new ArrayList <lement> (); RAN RAND = novo aleatório (); for (int i = 0; i <10; i ++) {int a = ran.nextInt (100); if (a> 50) {list.add (new concreteElement1 ()); } else {list.add (new concreteElement2 ()); }} Lista de retorno; }} classe pública client {public static void main (string [] args) {list <lement> list = objectStruture.getList (); para (elemento e: list) {e.Acept (new Visitor ()); }}} Vantagens do modo de visitante
Cumprir o princípio da responsabilidade única: em qualquer cenário em que o modo de visitante seja aplicável, as operações que precisam ser encapsuladas no visitante na classe de elementos devem ser operações que têm pouco a ver com a própria classe de elementos e são voláteis. Por um lado, o uso do modo de visitante está em conformidade com o princípio da responsabilidade única e, por outro lado, porque as operações encapsuladas são geralmente voláteis, quando ocorrem mudanças, a expansão da parte em mudança pode ser alcançada sem alterar a própria classe de elementos.
Boa escalabilidade: as classes de elementos podem estender diferentes operações, aceitando diferentes visitantes.
Cenários aplicáveis para o modo de visitante
Se houver algumas operações em um objeto que não estiverem relacionadas ao objeto (ou fracamente relacionado) e, para evitar essas operações que contaminam o objeto, você poderá usar o modo de visitante para encapsular essas operações no visitante.
Se houver operações semelhantes em um grupo de objetos, a fim de evitar um grande número de código duplicado, essas operações duplicadas também podem ser encapsuladas no visitante.
No entanto, o modo de visitante não é tão perfeito e também possui falhas fatais: adicionar novas classes de elementos é mais difícil. Através do código do padrão do visitante, podemos ver que, na classe de visitantes, cada classe de elemento possui seu método de processamento correspondente. Ou seja, cada classe de elemento precisa ser adicionada para modificar a classe de visitantes (incluindo também a classe de subclasse ou implementação da classe de visitantes), o que é bastante problemático para modificar. Ou seja, quando o número de classes de elemento é incerto, o modo de visitante deve ser usado com cautela. Portanto, o modo de visitante é mais adequado para refatorar as funções existentes. Por exemplo, se as funções básicas de um projeto foram determinadas, os dados das classes de elementos foram basicamente determinados e não serão alterados. Tudo o que mudará são as operações relevantes dentro desses elementos. No momento, podemos usar o modo de visitante para refatorar o código original, para que as funções originais possam ser modificadas sem modificar cada classe de elemento.
Resumir
Como GoF, o autor do padrão de design, descreve o modo de visitante: na maioria dos casos, você precisa usar o modo de visitante, mas depois de precisar, você realmente precisa. Claro que isso é apenas para os caras grandes. Na realidade (pelo menos no ambiente em que estou), muitas pessoas geralmente são viciadas em padrões de design. Ao usar um padrão de design, eles nunca consideram seriamente se o padrão que eles estão usando é adequado para esse cenário, mas muitas vezes apenas querem mostrar sua capacidade de controlar o design orientado a objetos. Se você tem essa mentalidade ao programar, muitas vezes abusa do padrão de design. Portanto, ao aprender padrões de design, você deve entender a aplicabilidade dos padrões. É necessário usar um padrão porque você entende suas vantagens, não para usar um padrão porque entende suas desvantagens; Em vez de usar um padrão porque você não entende suas desvantagens, não para usar um padrão porque não entende suas vantagens.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.