Patron Visiteur

Dans le patron Visiteur, nous utilisons une classe visiteur qui modifie l'algorithme d'exécution des classes d'éléments. Ainsi, l'algorithme d'exécution des éléments peut changer lorsque le visiteur change. Ce type de patron de conception est un patron comportemental. Selon le patron, les objets éléments acceptent les objets visiteurs, de sorte que les objets visiteurs peuvent traiter des opérations sur les objets éléments.

Introduction

intention

Il vise à séparer la structure de données des opérations effectuées sur elle, ce qui facilite l'ajout de nouvelles opérations sans modifier la structure de données elle-même.

Principaux problèmes traités

  • Il résout le problème de couplage entre les structures de données stables et les opérations variables, permettant aux opérations de changer indépendamment de la structure de données.

Cas d'utilisation

  • Lorsque vous devez effectuer plusieurs opérations différentes et indépendantes sur des objets d'une structure d'objets, en particulier lorsque ces opérations doivent éviter de « polluer » les classes d'objets elles-mêmes.

Approche d'implémentation

  • Définir l'interface Visiteur: Déclare une série de méthodes de visite, une méthode de visite correspondant à chaque classe d'élément dans la structure de données.
  • Créer des visiteurs concrets: Implémente l'interface Visiteur et fournit des implémentations concrètes pour chaque méthode de visite.
  • Définir l'interface Élément: Déclare une méthode qui accepte un visiteur.
  • Créer des éléments concrets: Implémente l'interface Élément ; chaque classe d'élément concret correspond à un objet concret dans la structure de données.

Code clé

  • Interface Visiteur: Contient des méthodes pour visiter différents éléments.
  • Visiteur concret: Implémente l'interface Visiteur et contient la logique de visite pour chaque classe d'élément.
  • Interface Élément: Contient une méthode qui accepte un visiteur.
  • Élément concret: Implémente l'interface Élément et fournit un point d'entrée permettant aux visiteurs d'y accéder.

Exemple d'application

  • Scène de l'invité: Un visiteur (comme vous) visite la maison d'un ami. L'ami, en tant qu'élément, fournit des informations, et le visiteur émet des jugements en fonction de ces informations.

Avantages

  • Principe de responsabilité unique: Le patron Visiteur respecte le principe de responsabilité unique ; chaque classe n'a qu'une seule responsabilité.
  • Extensibilité: Il est facile d'ajouter de nouvelles opérations à la structure de données.
  • Flexibilité: Les visiteurs peuvent changer indépendamment de la structure de données.

Inconvénients

  • Viole la loi de Déméter: Les éléments doivent exposer leurs informations internes aux visiteurs.
  • Les classes d'éléments sont difficiles à modifier: Les classes d'éléments doivent maintenir la compatibilité avec les visiteurs.
  • Dépend de classes concrètes: Le patron Visiteur dépend de classes concrètes plutôt que d'interfaces, ce qui viole le principe d'inversion des dépendances.

Suggestions d'utilisation

  • Lorsque la structure d'objets est stable, mais que plusieurs nouvelles opérations doivent y être définies, envisagez d'utiliser le patron Visiteur.
  • Lorsqu'il est nécessaire d'éviter que les opérations « polluent » les classes d'objets, utilisez le patron Visiteur pour encapsuler les opérations.

Notes

  • Le patron Visiteur peut être utilisé pour des fonctionnalités unifiées, telles que la génération de rapports, l'affichage de l'interface utilisateur, les intercepteurs et les filtres.

Les principaux rôles inclus

  • Visiteur:

    • Définit l'interface pour visiter les éléments.
  • Visiteur concret:

    • Implémente l'interface du visiteur pour fournir un accès et les opérations correspondantes pour chaque classe d'éléments concrète.
  • Élément:

    • Définit une méthode qui accepte un visiteur.
  • Élément concret:

    • Implémente l'interface d'élément, fournissant uneacceptméthode, permettant au visiteur d'accéder et d'opérer.
  • Structure d'objets (facultative):

    • Définit comment assembler des éléments concrets, comme une classe composite.
  • Client (facultatif):

    • Utilisez le patron Visiteur pour effectuer des opérations sur la structure d'objets.

Implémentation

Nous allons créer une [classe] qui définit des opérations d'acceptationComputerPartInterface.Keyboard、Mouse、MonitoretComputerImplémenteComputerPartclasse concrète de l'interface. Nous allons définir une autre interface.ComputerPartVisitor, qui définit les opérations de la classe visiteur.ComputerUtilisez des visiteurs concrets pour effectuer les actions correspondantes.

VisitorPatternDemo, notre classe de démonstration utiliseComputer、ComputerPartVisitorclasse pour démontrer l'utilisation du patron Visiteur.

访问者模式的 UML 图

Étape 1

Définissez une interface représentant un élément.

ComputerPart.java

public interface ComputerPart { public void accept(ComputerPartVisitor computerPartVisitor); }

Étape 2

Créez des classes d'entité qui étendent les classes ci-dessus.

Keyboard.java

public class Keyboard implements ComputerPart { @Override public void accept(ComputerPartVisitor computerPartVisitor) { computerPartVisitor.visit(this); } }

Monitor.java

public class Monitor implements ComputerPart { @Override public void accept(ComputerPartVisitor computerPartVisitor) { computerPartVisitor.visit(this); } }

Mouse.java

public class Mouse implements ComputerPart { @Override public void accept(ComputerPartVisitor computerPartVisitor) { computerPartVisitor.visit(this); } }

Computer.java

public class Computer implements ComputerPart { ComputerPart[] parts; public Computer(){ parts = new ComputerPart[] {new Mouse(), new Keyboard(), new Monitor()}; } @Override public void accept(ComputerPartVisitor computerPartVisitor) { for (int i = 0; i < parts.length; i++) { parts[i].accept(computerPartVisitor); } computerPartVisitor.visit(this); } }

Étape 3

Définir une interface représentant un visiteur.

ComputerPartVisitor.java

public interface ComputerPartVisitor { public void visit(Computer computer); public void visit(Mouse mouse); public void visit(Keyboard keyboard); public void visit(Monitor monitor); }

Étape 4

Créez des visiteurs concrets qui implémentent les classes ci-dessus.

ComputerPartDisplayVisitor.java

public class ComputerPartDisplayVisitor implements ComputerPartVisitor { @Override public void visit(Computer computer) { System.out.println("Affichage de l'ordinateur."); } @Override public void visit(Mouse mouse) { System.out.println("Affichage de la souris."); } @Override public void visit(Keyboard keyboard) { System.out.println("Affichage du clavier."); } @Override public void visit(Monitor monitor) { System.out.println("Affichage du moniteur."); } }

Étape 5

UtilisationComputerPartDisplayVisitorPour afficherComputerComposants de.

VisitorPatternDemo.java

public class VisitorPatternDemo { public static void main(String[] args) { ComputerPart computer = new Computer(); computer.accept(new ComputerPartDisplayVisitor()); } }

Étape 6

Exécutez le programme et affichez les résultats :

Displaying Mouse.
Displaying Keyboard.
Displaying Monitor.
Displaying Computer.
autres extensions