mode visiteur

Dans le Visitor Pattern, nous utilisons une classe de visiteur, qui modifie l'algorithme d'exécution de la classe d'élément. De cette manière, l'algorithme d'exécution de l'élément peut changer au fur et à mesure que le visiteur change. Ce type de modèle de conception est un modèle comportemental. Selon le schéma, l'objet élément a accepté un objet visiteur afin que l'objet visiteur puisse gérer les opérations sur l'objet élément.

Introduction

Intention : Séparer principalement les structures de données des opérations de données.

Résout principalement : Problèmes de structure de données stable et de couplage d'opérations volatiles.

Quand utiliser : Vous devez effectuer de nombreuses opérations différentes et non liées sur les objets dans une structure d'objet, et vous devez éviter de laisser ces opérations "polluer" les classes de ces objets. Utiliser l'accès Le modèle Orator les encapsule dans des classes.

Comment résoudre : Ajouter une interface externe pour recevoir les visiteurs dans la classe visitée.

Code clé : Il existe une méthode dans la classe de base de données qui accepte les visiteurs et transmet sa propre référence au visiteur.

Exemple d'application : Vous êtes un invité chez un ami, vous êtes le visiteur, l'ami accepte votre visite, vous transmettez la description de l'ami, puis portez un jugement sur la description de l'ami , c'est le mode Visiteur.

Avantages : 1. Respecter le principe de responsabilité unique. 2. Excellente évolutivité. 3. Flexibilité.

Inconvénients : 1. Des éléments spécifiques divulguent des détails aux visiteurs, ce qui viole le principe Dimit. 2. Il est difficile de modifier des éléments spécifiques. 3. Il viole le principe d’inversion des dépendances et s’appuie sur des classes concrètes plutôt que sur des abstractions.

Scénarios d'utilisation : 1. La classe correspondant à l'objet dans la structure objet change rarement, mais il est souvent nécessaire de définir de nouvelles opérations sur cette structure objet. 2. De nombreuses opérations différentes et sans rapport doivent être effectuées sur les objets dans une structure d'objets, et vous devez éviter de laisser ces opérations "polluer" les classes de ces objets, et vous ne souhaitez pas modifier ces classes lors de l'ajout de nouvelles opérations.

Remarque : Les visiteurs peuvent unifier les fonctions et créer des rapports, une interface utilisateur, des intercepteurs et des filtres.

Implémentation

Nous allons créer une interface ComputerPart qui définit une opération acceptée. Keyboard, Mouse, Monitor et Computer sont des classes d'entités qui implémentent l'interface ComputerPart. Nous définirons une autre interface ComputerPartVisitor qui définit les opérations de la classe visiteur. Ordinateur utilise les visiteurs de l'entité pour effectuer les actions correspondantes.

VisitorPatternDemo, notre classe de démonstration utilise les classes Computer, ComputerPartVisitor pour démontrer l'utilisation du modèle de visiteur.

Étape 1

Définissez une interface qui représente l'élément.

ComputerPart.java

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

Étape 2

Créez une classe d'entité qui étend la classe ci-dessus.

Clavier.java

public class Keyboard  implements ComputerPart {

   @Override
   public void accept(ComputerPartVisitor computerPartVisitor) {
      computerPartVisitor.visit(this);
   }
}

Moniteur.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 qui représente le 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 un visiteur d'entité qui implémente la classe ci-dessus.

ComputerPartDisplayVisitor.java

public class ComputerPartDisplayVisitor implements ComputerPartVisitor {

   @Override
   public void visit(Computer computer) {
      System.out.println("Displaying Computer.");
   }

   @Override
   public void visit(Mouse mouse) {
      System.out.println("Displaying Mouse.");
   }

   @Override
   public void visit(Keyboard keyboard) {
      System.out.println("Displaying Keyboard.");
   }

   @Override
   public void visit(Monitor monitor) {
      System.out.println("Displaying Monitor.");
   }
}

Étape 5

Utilisez ComputerPartDisplayVisitor pour afficher les composants de Ordinateur .

VisitorPatternDemo.java

public class VisitorPatternDemo {
   public static void main(String[] args) {

      ComputerPart computer = new Computer();
      computer.accept(new ComputerPartDisplayVisitor());
   }
}

Étape 6

Vérifiez la sortie.

Displaying Mouse.
Displaying Keyboard.
Displaying Monitor.
Displaying Computer.