Besucher-Muster

Im Besuchermuster verwenden wir eine Besucherklasse, die den Ausführungsalgorithmus von Elementklassen ändert. Auf diese Weise kann sich der Ausführungsalgorithmus von Elementen ändern, wenn sich der Besucher ändert. Diese Art von Entwurfsmuster ist ein Verhaltensmuster. Gemäß dem Muster akzeptieren Elementobjekte Besucherobjekte, sodass Besucherobjekte Operationen an Elementobjekten verarbeiten können.

Einführung

Absicht

Es zielt darauf ab, die Datenstruktur von den darauf ausgeführten Operationen zu trennen, wodurch es einfacher wird, neue Operationen hinzuzufügen, ohne die Datenstruktur selbst zu ändern.

Behandelte Hauptprobleme

  • Es löst das Kopplungsproblem zwischen stabilen Datenstrukturen und variablen Operationen und ermöglicht es, Operationen unabhängig von der Datenstruktur zu ändern.

Anwendungsfall

  • Wenn Sie mehrere unterschiedliche und unabhängige Operationen auf Objekten in einer Objektstruktur ausführen müssen, insbesondere wenn diese Operationen vermeiden sollen, die Objektklassen selbst zu „verschmutzen“.

Implementierungsansatz

  • Besucher-Schnittstelle definieren: Deklariert eine Reihe von Besuchsmethoden, wobei eine Besuchsmethode jeder Elementklasse in der Datenstruktur entspricht.
  • Konkrete Besucher erstellen: Implementiert die Besucher-Schnittstelle und bietet konkrete Implementierungen für jede Besuchsmethode.
  • Element-Schnittstelle definieren: Deklariert eine Methode, die einen Besucher akzeptiert.
  • Konkrete Elemente erstellen: Implementiert die Element-Schnittstelle; jede konkrete Elementklasse entspricht einem konkreten Objekt in der Datenstruktur.

Schlüsselcode

  • Besucher-Schnittstelle: Enthält Methoden zum Besuchen verschiedener Elemente.
  • Konkreter Besucher: Implementiert die Besucher-Schnittstelle und enthält die Besuchslogik für jede Elementklasse.
  • Element-Schnittstelle: Enthält eine Methode, die einen Besucher akzeptiert.
  • Konkretes Element: Implementiert die Element-Schnittstelle und bietet einen Einstiegspunkt für den Zugriff durch Besucher.

Anwendungsbeispiel

  • Gast-Szene: Ein Besucher (wie Sie) besucht das Zuhause eines Freundes. Der Freund als Element stellt Informationen bereit, und der Besucher trifft anhand der Informationen Entscheidungen.

Vorteile

  • Single-Responsibility-Prinzip: Das Besuchermuster entspricht dem Single-Responsibility-Prinzip; jede Klasse hat nur eine Verantwortlichkeit.
  • Erweiterbarkeit: Es ist einfach, neue Operationen zur Datenstruktur hinzuzufügen.
  • Flexibilität: Besucher können unabhängig von der Datenstruktur geändert werden.

Nachteile

  • Verstößt gegen das Gesetz von Demeter: Elemente müssen ihre internen Informationen gegenüber Besuchern offenlegen.
  • Elementklassen sind schwer zu ändern: Elementklassen müssen die Kompatibilität mit Besuchern aufrechterhalten.
  • Hängt von konkreten Klassen ab: Das Besucher-Muster hängt von konkreten Klassen statt von Schnittstellen ab, was gegen das Dependency-Inversion-Prinzip verstößt.

Verwendungshinweise

  • Wenn die Objektstruktur stabil ist, aber mehrere neue Operationen darauf definiert werden müssen, sollten Sie das Besucher-Muster in Betracht ziehen.
  • Wenn vermieden werden muss, dass Operationen Objektklassen „verschmutzen“, verwenden Sie das Besucher-Muster, um die Operationen zu kapseln.

Hinweise

  • Das Besucher-Muster kann für einheitliche Funktionalität verwendet werden, wie z. B. Berichterstellung, Anzeige der Benutzeroberfläche, Interceptoren und Filter.

Die Hauptrollen umfassen

  • Besucher:

    • Definiert die Schnittstelle zum Besuchen von Elementen.
  • Konkreter Besucher:

    • Implementieren Sie die Besucher-Schnittstelle, um Zugriff und entsprechende Operationen für jede konkrete Elementklasse bereitzustellen.
  • Element:

    • Definiert eine Methode, die einen Besucher akzeptiert.
  • Konkretes Element:

    • Implementieren Sie die Element-Schnittstelle und stellen Sie eineacceptMethode bereit, die es dem Besucher ermöglicht, zu besuchen und zu operieren.
  • Objektstruktur (optional):

    • Definiert, wie konkrete Elemente zusammengesetzt werden, z. B. durch eine Composite-Klasse.
  • Client (optional):

    • Verwenden Sie das Besucher-Muster, um Operationen auf der Objektstruktur auszuführen.

Implementierung

Wir werden eine [class] erstellen, die akzeptierende Operationen definiertComputerSchnittstelle.Keyboard、Mouse、MonitorundComputerImplementsComputerPartKonkrete Klasse der Schnittstelle. Wir werden eine weitere Schnittstelle definieren.ComputerPartVisitor, das die Operationen der Besucherklasse definiert.ComputerVerwenden Sie konkrete Besucher, um entsprechende Aktionen auszuführen.

VisitorPatternDemo, unsere Demonstrationsklasse verwendetComputer、ComputerPartVisitorKlasse, um die Verwendung des Besucher-Musters zu demonstrieren.

访问者模式的 UML 图

Schritt 1

Definieren Sie eine Schnittstelle, die ein Element repräsentiert.

ComputerPart.java

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

Schritt 2

Erstellen Sie Entitätsklassen, die die oben genannten Klassen erweitern.

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); } }

Schritt 3

Definiere eine Schnittstelle, die einen Besucher repräsentiert.

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); }

Schritt 4

Erstellen Sie konkrete Besucher, die die oben genannten Klassen implementieren.

ComputerPartDisplayVisitor.java

public class ComputerPartDisplayVisitor implements ComputerPartVisitor { @Override public void visit(Computer computer) { System.out.println("Computer wird angezeigt."); } @Override public void visit(Mouse mouse) { System.out.println("Maus wird angezeigt."); } @Override public void visit(Keyboard keyboard) { System.out.println("Tastatur wird angezeigt."); } @Override public void visit(Monitor monitor) { System.out.println("Monitor wird angezeigt."); } }

Schritt 5

VerwendungComputerPartDisplayVisitorZum Anzeigen vonComputer-Komponenten.

VisitorPatternDemo.java

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

Schritt 6

Führen Sie das Programm aus und geben Sie die Ergebnisse aus:

Displaying Mouse.
Displaying Keyboard.
Displaying Monitor.
Displaying Computer.
Weitere Erweiterungen