What is Visitor Pattern?
The Visitor Pattern is a behavioral design pattern that allows you to separate an algorithm from an object structure on which it operates. This pattern is particularly useful when you have a large number of classes derived from a common superclass and you want to perform operations on these classes without modifying their structure. In simple terms, the Visitor Pattern enables you to add new operations to existing classes without changing their code.
Understanding the Problem
Let’s consider a scenario where we have a class hierarchy of different shapes, such as circles, rectangles, and triangles. Each shape has its own methods for drawing, calculating area, and perimeter. Now, suppose we want to add a new operation, such as calculating the total area of all shapes in the hierarchy. If we modify each shape’s class to include this operation, we will end up with a lot of duplicated code. This violates the Open/Closed Principle, which states that software entities should be open for extension but closed for modification.
How the Visitor Pattern Works
The Visitor Pattern solves this problem by introducing a visitor class that encapsulates the new operation. The visitor class is responsible for performing the operation on each shape in the hierarchy. To implement this pattern, we follow these steps:
1. Define a common interface for the elements in the class hierarchy (e.g., Shape).
2. Implement concrete classes for each element in the hierarchy (e.g., Circle, Rectangle, Triangle).
3. Define a visitor interface with methods for each operation to be performed on the elements.
4. Implement concrete visitor classes for each operation.
5. Define an accept method in the element classes that takes a visitor object and calls the appropriate visitor method.
Example Implementation
Here’s a simple example to illustrate the Visitor Pattern:
“`java
// Step 1: Define a common interface for the elements
interface Shape {
void accept(Visitor visitor);
}
// Step 2: Implement concrete classes for each element
class Circle implements Shape {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
class Rectangle implements Shape {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
class Triangle implements Shape {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
// Step 3: Define a visitor interface
interface Visitor {
void visit(Circle circle);
void visit(Rectangle rectangle);
void visit(Triangle triangle);
}
// Step 4: Implement concrete visitor classes
class AreaCalculator implements Visitor {
public void visit(Circle circle) {
System.out.println(“Calculating area of circle: ” + circle.calculateArea());
}
public void visit(Rectangle rectangle) {
System.out.println(“Calculating area of rectangle: ” + rectangle.calculateArea());
}
public void visit(Triangle triangle) {
System.out.println(“Calculating area of triangle: ” + triangle.calculateArea());
}
}
// Step 5: Define an accept method in the element classes
class ShapeCollection {
private List
public void addShape(Shape shape) {
shapes.add(shape);
}
public void accept(Visitor visitor) {
for (Shape shape : shapes) {
shape.accept(visitor);
}
}
}
“`
In this example, the `AreaCalculator` visitor class encapsulates the operation of calculating the area of each shape. The `ShapeCollection` class contains a list of shapes and accepts a visitor to perform the operation on each shape.
The Visitor Pattern provides a flexible and maintainable solution to add new operations to existing class hierarchies without modifying their code. By separating the algorithm from the object structure, the pattern promotes code reuse and adheres to the Open/Closed Principle.
