Visitor Design Pattern in Java

1. Definition

The Visitor Design Pattern defines a mechanism to add further operations to objects without having to modify them. It encapsulates a new operation to be performed on elements of an object structure without changing the classes on which it operates.

2. Problem Statement

How can you add new operations to existing object structures without modifying the structures, especially when new operations are needed frequently and the object structure classes are rarely changed?

3. Solution

Separate the algorithms from the objects on which they operate, by introducing a set of visitor objects. The visitor object has a distinct operation to perform on each kind of element in the object structure.

4. Real-World Use Cases

1. A word processing software that checks documents for various types of formatting errors.

2. Extending a compiler with new ways to analyze or translate source code.

3. Graphic editors that offer tools to process and transform graphical elements in various ways.

5. Implementation Steps

1. Define an abstract Visitor class with a visit method for each type of element in the structure.

2. Each element in the object structure declares an accept method that takes a visitor as an argument.

3. Concrete elements implement the accept method to invoke the visit method on the visitor.

4. Concrete visitors implement all the visit methods, one for each type of element.

6. Implementation

// Element interface
interface Element {
    void accept(Visitor visitor);
}

// Concrete Elements
class ElementA implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationA() {
        return "ElementA";
    }
}

class ElementB implements Element {
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public String operationB() {
        return "ElementB";
    }
}

// Visitor interface
interface Visitor {
    void visit(ElementA element);
    void visit(ElementB element);
}

// Concrete Visitor
class ConcreteVisitor implements Visitor {
    public void visit(ElementA element) {
        System.out.println("Visited " + element.operationA());
    }

    public void visit(ElementB element) {
        System.out.println("Visited " + element.operationB());
    }
}

// Client
public class VisitorDemo {
    public static void main(String[] args) {
        Element[] elements = new Element[]{new ElementA(), new ElementB()};
        Visitor visitor = new ConcreteVisitor();

        for (Element element : elements) {
            element.accept(visitor);
        }
    }
}

Output:

Visited ElementA
Visited ElementB

Explanation

The Visitor pattern allows us to add further operations to objects without modifying them. The actual operation (visitor) is separated from the objects' structure. In the given example, ElementA and ElementB allow a Visitor to visit them and perform some operations. The ConcreteVisitor specifies what kind of operations will be performed.

7. When to use?

Use the Visitor Pattern when:

1. You need to perform operations on objects in a structure, and those operations need to be decoupled from the objects themselves.

2. New operations are needed frequently, but the object structure classes rarely change.

3. Classes defining the object structure are distinct and unrelated by inheritance.