Visitor pattern in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the Visitor interface method for visiting an Element.

LLD

interface Visitor {
    void visit([1] element);
}

Drag options to blanks, or click blank then click option'

AElement

BVisitor

CObject

DElementVisitor

Attempts:

3 left

💡 Hint

Common Mistakes

Using Visitor as parameter type instead of Element.

Using Object which is too generic.

The Visitor interface defines a visit method that takes an Element object to perform operations on it.

2fill in blank

medium

Complete the code to implement the accept method in the Element class that accepts a Visitor.

LLD

class Element {
    void accept([1] visitor) {
        visitor.visit(this);
    }
}

Drag options to blanks, or click blank then click option'

AObject

BElement

CVisitor

DElementVisitor

Attempts:

3 left

💡 Hint

Common Mistakes

Using Element as parameter type instead of Visitor.

Using Object which is too generic.

The accept method takes a Visitor object and calls its visit method passing itself.

3fill in blank

hard

Fix the error in the ConcreteVisitor class method signature for visiting an Element.

LLD

class ConcreteVisitor implements Visitor {
    public void visit([1] element) {
        // operation implementation
    }
}

Drag options to blanks, or click blank then click option'

AConcreteElement

BElement

CObject

DVisitor

Attempts:

3 left

💡 Hint

Common Mistakes

Using ConcreteElement which is more specific than the interface.

Using Visitor or Object which do not match the interface.

The ConcreteVisitor must implement the visit method with the Element parameter type as declared in Visitor interface.

4fill in blank

hard

Fill both blanks to complete the double dispatch call in the client code.

LLD

Element element = new ConcreteElement();
Visitor visitor = new ConcreteVisitor();
element.[1](visitor);
visitor.[2](element);

Drag options to blanks, or click blank then click option'

Aaccept

Bvisit

Cexecute

Dhandle

Attempts:

3 left

💡 Hint

Common Mistakes

Using execute or handle which are not standard Visitor pattern methods.

Swapping accept and visit method calls.

The client calls accept on the element passing the visitor, then visitor calls visit on the element to perform operation.

5fill in blank

hard

Fill all three blanks to complete the Visitor pattern structure with multiple elements and visitors.

LLD

interface Visitor {
    void visit([1] elementA);
    void visit([2] elementB);
}

class ConcreteVisitor implements Visitor {
    public void visit([3] elementA) {
        // implementation
    }
    public void visit(ElementB elementB) {
        // implementation
    }
}

Drag options to blanks, or click blank then click option'

AElementA

BElementB

DElementC

Attempts:

3 left

💡 Hint

Common Mistakes

Using ElementC which is not declared in the interface.

Mismatching parameter types between interface and implementation.

The Visitor interface declares visit methods for each Element type. ConcreteVisitor implements these methods with matching parameter types.

Practice

1. What is the main purpose of the Visitor pattern in system design?

easy

A. To separate operations from the objects on which they operate

B. To create multiple instances of a class

C. To restrict access to certain parts of an object

D. To simplify database queries

Solution

1. Step 1: Understand the Visitor pattern concept

   The Visitor pattern allows defining new operations on objects without changing their classes.

2. Step 2: Identify the main goal

   Its main goal is to separate the operation logic from the object structure to keep code flexible.

3. Final Answer:

   To separate operations from the objects on which they operate -> Option A

4. Quick Check:

   Visitor pattern = separates operations [OK]

Hint: Visitor pattern separates operations from objects [OK]

Common Mistakes:

• Confusing Visitor with Singleton pattern
• Thinking it creates object instances
• Assuming it controls access permissions

2. Which of the following is the correct method signature for a visitor interface method visiting an element called ElementA?

easy

A. void accept(ElementA element);

B. void acceptVisitor(ElementA visitor);

C. void visitElementA();

D. void visit(ElementA element);

Solution

1. Step 1: Recall Visitor interface method naming

   The visitor interface defines methods named visit with the element type as parameter.

2. Step 2: Match correct signature

   The correct signature is void visit(ElementA element); to visit ElementA.

3. Final Answer:

   void visit(ElementA element); -> Option D

4. Quick Check:

   Visitor method = visit(Element) [OK]

Hint: Visitor methods are named visit(Element) [OK]

Common Mistakes:

• Confusing accept and visit method names
• Using no parameters in visit method
• Swapping visitor and element in parameters

3. Given the following code snippet, what will be the output?

class ElementA {
  accept(visitor) {
    visitor.visit(this);
  }
}

class PrintVisitor {
  visit(element) {
    console.log('Visited element');
  }
}

const element = new ElementA();
const visitor = new PrintVisitor();
element.accept(visitor);

medium

A. Visited ElementA

B. Error: visit is not a function

C. Visited element

D. No output

Solution

1. Step 1: Trace accept method call

   The accept method calls visitor.visit(this), passing the element instance.

2. Step 2: Check visit method behavior

   The visit method logs 'Visited element' to the console.

3. Final Answer:

   Visited element -> Option C

4. Quick Check:

   Visitor.visit logs message [OK]

Hint: Visitor.visit prints message when accept calls it [OK]

Common Mistakes:

• Expecting element type name in output
• Thinking visit method is missing
• Assuming no output without explicit return

4. Identify the error in this Visitor pattern implementation:

class ElementB {
  accept(visitor) {
    visitor.accept(this);
  }
}

class ConcreteVisitor {
  visit(element) {
    console.log('Visiting element');
  }
}

medium

A. ElementB calls visitor.accept instead of visitor.visit

B. ConcreteVisitor should not have a visit method

C. accept method should return a value

D. ElementB should not have an accept method

Solution

1. Step 1: Check accept method call

   The accept method calls visitor.accept(this), but visitor has no accept method.

2. Step 2: Identify correct visitor method

   The visitor interface defines visit methods, so accept should call visitor.visit(this).

3. Final Answer:

   ElementB calls visitor.accept instead of visitor.visit -> Option A

4. Quick Check:

   accept calls visit, not accept [OK]

Hint: accept calls visitor.visit, not visitor.accept [OK]

Common Mistakes:

• Confusing method names accept and visit
• Expecting accept to return a value
• Removing accept method from element

5. You have a system with multiple element types and want to add a new operation without modifying existing element classes. How does the Visitor pattern help in this scenario?

hard

A. By using inheritance to extend element classes with new operations

B. By creating a new visitor class implementing the operation for all element types

C. By adding new methods to each element class directly

D. By storing operations inside element objects as data

Solution

1. Step 1: Understand the problem of adding new operations

   Modifying existing element classes is risky and breaks encapsulation.

2. Step 2: Apply Visitor pattern solution

   Create a new visitor class that implements the new operation for all element types, keeping element classes unchanged.

3. Final Answer:

   By creating a new visitor class implementing the operation for all element types -> Option B

4. Quick Check:

   Visitor adds operations via new visitor classes [OK]

Hint: Add new visitor class for new operations [OK]

Common Mistakes:

• Modifying element classes directly
• Using inheritance to add operations
• Embedding operations as data in elements