Visitor Pattern

The Visitor Pattern is a behavioral design pattern that allows you to add further operations to objects without modifying their structure. It separates an algorithm from the object structure on which it operates, thereby enabling the addition of new operations without altering the classes of the elements on which it operates. This pattern is particularly useful when dealing with complex object structures and is widely used in scenarios where operations need to be performed on objects of various types.

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

// Concrete Elements
class Book implements Item {
    private String title;
    private double price;

    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }

    public String getTitle() { return title; }
    public double getPrice() { return price; }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

class Electronics implements Item {
    private String name;
    private double price;

    public Electronics(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() { return name; }
    public double getPrice() { return price; }

    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// Visitor Interface
interface Visitor {
    void visit(Book book);
    void visit(Electronics electronics);
}

// Concrete Visitors
class CostCalculatorVisitor implements Visitor {
    private double totalCost;

    public double getTotalCost() { return totalCost; }

    @Override
    public void visit(Book book) {
        totalCost += book.getPrice();
        System.out.println("Book: " + book.getTitle() + ", Cost: $" + book.getPrice());
    }

    @Override
    public void visit(Electronics electronics) {
        totalCost += electronics.getPrice();
        System.out.println("Electronics: " + electronics.getName() + ", Cost: $" + electronics.getPrice());
    }
}

class DescriptionVisitor implements Visitor {
    private StringBuilder description;

    public DescriptionVisitor() {
        description = new StringBuilder();
    }

    public String getDescription() { return description.toString(); }

    @Override
    public void visit(Book book) {
        description.append("Book: ").append(book.getTitle()).append("\n");
    }

    @Override
    public void visit(Electronics electronics) {
        description.append("Electronics: ").append(electronics.getName()).append("\n");
    }
}

// Object Structure
class ShoppingCart {
    private List<Item> items;

    public ShoppingCart() {
        items = new ArrayList<>();
    }

    public void addItem(Item item) {
        items.add(item);
    }

    public void applyVisitor(Visitor visitor) {
        for (Item item : items) {
            item.accept(visitor);
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        // Create object structure
        ShoppingCart cart = new ShoppingCart();
        cart.addItem(new Book("Clean Code", 50.0));
        cart.addItem(new Electronics("Laptop", 1000.0));
        cart.addItem(new Book("Design Patterns", 60.0));

        // Apply CostCalculatorVisitor
        System.out.println("Calculating total cost:");
        CostCalculatorVisitor costVisitor = new CostCalculatorVisitor();
        cart.applyVisitor(costVisitor);
        System.out.println("Total Cost: $" + costVisitor.getTotalCost());

        // Apply DescriptionVisitor
        System.out.println("\nGenerating description:");
        DescriptionVisitor descVisitor = new DescriptionVisitor();
        cart.applyVisitor(descVisitor);
        System.out.println("Cart Contents:\n" + descVisitor.getDescription());
    }
}

/*
Calculating total cost:
Book: Clean Code, Cost: $50.0
Electronics: Laptop, Cost: $1000.0
Book: Design Patterns, Cost: $60.0
Total Cost: $1110.0

Generating description:
Cart Contents:
Book: Clean Code
Electronics: Laptop
Book: Design Patterns
*/Code language: PHP (php)