<p>This article explains about the <strong>visitor pattern</strong> of the<strong><a href="https://dineshonjava.com/design-patterns_25/"> GoF Design Behavior patterns</a></strong>. In the <strong>visitor design pattern</strong>, the visitor class is used to alter the algorithm that is executing as part of the element class. This is an easy methodology to control the algorithm executing for elements by using the visitor class, as the executing algorithm varies with the variance in the visitor class.</p>
<p>The Visitor class is considered as a type of <strong><a href="https://dineshonjava.com/behavioral-design-pattern/">Behavior pattern</a></strong> that presents an implementation of the exchange of place with the exchange of control mechanism. As the object of the element, the class must provide a place to the object of the visitor class in order for it to control the element class. The visitor class is the controller of all variance in the operations of the element class.</p>
<h2>Visitor Pattern</h2>
<div style="text-align: left;">
<blockquote><p><strong>According to the Gang of Four:</strong></p>
<div style="text-align: left;">Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates.</div>
</blockquote>
</div>
<div style="text-align: left;">
<blockquote><p><strong>also read:</strong></p>
<ul style="text-align: left;">
<li><a title="https://dineshonjava.com/observer-pattern-design-patterns-java/" href="https://dineshonjava.com/observer-pattern-design-patterns-java/">Observer Design Pattern</a></li>
<li><a title="https://dineshonjava.com/chain-responsibility-pattern/" href="https://dineshonjava.com/chain-responsibility-pattern/">Chain of responsibility Pattern</a></li>
<li><a title="https://dineshonjava.com/command-pattern-design-patterns-java/" href="https://dineshonjava.com/command-pattern-design-patterns-java/">Command Design Pattern</a></li>
<li><a title="https://dineshonjava.com/strategy-pattern-design-patterns-java/" href="https://dineshonjava.com/strategy-pattern-design-patterns-java/">Strategy Design Pattern</a></li>
<li><a title="https://dineshonjava.com/template-method-pattern-design-java/" href="https://dineshonjava.com/template-method-pattern-design-java/">Template method Design Pattern</a></li>
<li><a title="https://dineshonjava.com/interpreter-pattern-design-patterns-java/" href="https://dineshonjava.com/interpreter-pattern-design-patterns-java/">Interpreter Design Pattern</a></li>
<li><a title="https://dineshonjava.com/iterator-pattern-design-patterns-java/" href="https://dineshonjava.com/iterator-pattern-design-patterns-java/">Iterator Design Pattern</a></li>
<li><a title="https://dineshonjava.com/mediator-pattern-design-patterns-java/" href="https://dineshonjava.com/mediator-pattern-design-patterns-java/">Mediator Design Pattern</a></li>
<li><a title="https://dineshonjava.com/memento-pattern-design-patterns-java/" href="https://dineshonjava.com/memento-pattern-design-patterns-java/">Memento Design Pattern</a></li>
<li><a title="https://dineshonjava.com/creational-design-patterns/" href="https://dineshonjava.com/creational-design-patterns//">Creational GoF Design Patterns</a></li>
<li><a title="https://dineshonjava.com/structural-design-patterns/" href="https://dineshonjava.com/structural-design-patterns/">Structural GoF Design Patterns</a></li>
</ul>
</blockquote>
</div>
<h2>UML Class Diagram<br />
<img class="aligncenter wp-image-3466 size-full" src="https://dineshonjava.com/wp-content/uploads/2017/12/visitor.gif" alt="visitor pattern" width="467" height="533" /></h2>
<h3>Visitor Class</h3>
<ul>
<li>The visitor class performs the mechanism of controlling any sort of variance in the element class. The object of the visitor class resides in the element class for control.</li>
</ul>
<h3>Element Class</h3>
<ul>
<li>The element class is the main class performing critical operations whose variations are controlled by the visitor class.</li>
<li>The operation that is performed on the element is represented through visitor behavioural pattern. A new operation can be defined by the Visitor class without any alteration to the normal classes belonging to the element being operated on. Many operations that are not related to each other are performed on a structure that is composed of heterogeneous node objects which can pollute the classes of the node objects.</li>
<li>To avoid pollution, querying is performed on nodes to determine the correct type and point the operation to it. This is quite inefficient as it cost a lot of time and resources for querying every node and waiting for a response. The Visitor Behavioral Pattern provides a solution with this by abstracting functionalities on element objects aggregated together in a hierarchical structure.</li>
</ul>
<div style="background-color: #f2f9fc; border-radius: 3px; border: 1px solid #c9e6f2; line-height: 1.45; padding: 16px 16px 16px 16px;">
<h2 dir="ltr">Spring 5 Design Pattern Book</h2>
<div dir="ltr" style="color: #20124d; font-family: 'calibri' , sans-serif; font-size: 13pt; text-align: justify;">You could purchase my <strong>Spring 5 book</strong> that is with title name &#8220;<strong>Spring 5 Design Pattern</strong>&#8220;. This book is available on the <a href="https://www.amazon.in/Spring-Design-Patterns-Dinesh-Rajput/dp/1788299450/ref=sr_1_1?ie=UTF8&;qid=1507925340&;sr=8-1&;keywords=spring+5+design+pattern" target="_blank" rel="noopener noreferrer"><strong>Amazon</strong></a> and <a href="https://www.packtpub.com/application-development/spring-5-design-patterns" target="_blank" rel="noopener noreferrer"><strong>Packt</strong></a> publisher website. Learn various <strong>design patterns</strong> and <strong>best practices</strong> in Spring 5 and use them to solve common design problems. You could use an author discount to purchase this book by using code- &#8220;<strong>AUTHDIS40</strong>&#8220;.</div>
<div dir="ltr"></div>
<div dir="ltr"><a href="https://www.amazon.in/Spring-Design-Patterns-Dinesh-Rajput/dp/1788299450/ref=sr_1_1?s=books&;ie=UTF8&;qid=1512607966&;sr=1-1&;keywords=dinesh+rajput" target="_blank" rel="noopener noreferrer"><img class="aligncenter wp-image-3053 size-medium" title="Spring-5-Design-Pattern" src="https://dineshonjava.com/wp-content/uploads/2013/03/Spring-5-design-pattern-243x300.jpg" width="243" height="300" /></a></div>
</div>
<p>The Element classes are created in such a way that includes only the necessary functionalities and the Visitor subclasses are created that provide the additional functionality for the Element class. A double dispatch mechanism is implemented by the Visitor Class in which, the request’s name and the Visitor type and Element type both act as receivers these things determine the operation that will be performed.</p>
<h2>Visitor Design Pattern Implementation</h2>
<p>This can be implemented by creating a Visitor hierarchy through the pure virtual class of the visitor. A method visit() is declared in the base class of the Visitor and it is overloaded in the child/derived classes by using the specific methodology of querying and casting. The visitor() method receives the pointer to the derived class for the Element class. The base class of the Element class has an accept() method which accepts the pointer to the base class of the Visitor class. The accept() method can be implemented on the Element’s concrete derived class by calling the visit() method on the Visitor’s derived instance.</p>
<p>The accept() method is responsible for the selection of the Element class to be controlled and the visit() method allocated the control to the correct Visitor instance. This allows related and unrelated operations to be performed on an object that is aggregated into a single hierarchical structure.</p>
<h2>Visitor Pattern Sample Example</h2>
<p>In this sample real-world example, we demonstrate the Visitor pattern in which two objects traverse a list of Employees and perform the same operation on each Employee. There are two visitor objects define different operations. These operations are one adjusts vacation days and the other income.</p>
<p>VisitorPatternDemo, our demo class, will use Employee and Visitor classes to demonstrate the use of visitor pattern.</p>
<h3>Step 1: Define an interface to represent element.<br />
Element.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public interface Element {
	
	void accept(IVisitor visitor);
}
</pre>
<h3>Step 2: Create concrete classes extending the above class.<br />
Employee.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public class Employee implements Element {
	
	private String _name;
 private double _income;
 private int _vacationDays;
 
 
	public Employee(String _name, double _income, int _vacationDays) {
		super();
		this._name = _name;
		this._income = _income;
		this._vacationDays = _vacationDays;
	}

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

	public String get_name() {
		return _name;
	}

	public void set_name(String _name) {
		this._name = _name;
	}

	public double get_income() {
		return _income;
	}

	public void set_income(double _income) {
		this._income = _income;
	}

	public int get_vacationDays() {
		return _vacationDays;
	}

	public void set_vacationDays(int _vacationDays) {
		this._vacationDays = _vacationDays;
	}
	
}

</pre>
<h3>Director.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public class Director extends Employee {

	public Director() {
		super("Anamika", 45000.0, 20);
	}

}

</pre>
<h3>President.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public class President extends Employee {

	public President() {
		super("Arnav", 65000.0, 25);
	}

}

</pre>
<h3>Clerk.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public class Clerk extends Employee {

	public Clerk() {
		super("Dinesh", 35000.0, 18);
	}

}

</pre>
<h3>Employees.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Dinesh.Rajput
 *
 */
public class Employees {
	
	// Setup employee collection
	List empList = new ArrayList<;>;();
	
	public void add(Employee employee){
		empList.add(employee);
 }

 public void remove(Employee employee){
 	empList.remove(employee);
 }

 public void accept(IVisitor visitor){
 	for(Employee employee : empList)	{
 		employee.accept(visitor);
 	}
 	System.out.println();
 }
}

</pre>
<h3>Step 3: Define an interface to represent visitor.<br />
IVisitor.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public interface IVisitor {
	
	void visit(Element element);
}

</pre>
<h3>Step 4: Create a concrete visitor implementing the above class.<br />
IncomeVisitor.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public class IncomeVisitor implements IVisitor {

	@Override
	public void visit(Element element) {
		Employee employee = (Employee) element;
		// Provide 10% pay raise
		employee.set_income(employee.get_income()*1.10);
		System.out.println(employee.getClass().getSimpleName()+" "+employee.get_name() +"'s new income: "+employee.get_income());
	}
}

</pre>
<h3>VacationVisitor.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public class VacationVisitor implements IVisitor {

	@Override
	public void visit(Element element) {
		Employee employee = (Employee) element;
		// Provide 3 extra vacation days
		employee.set_vacationDays(employee.get_vacationDays()+3);
		System.out.println(employee.getClass().getSimpleName()+" "+employee.get_name() +"'s vacation days: "+employee.get_vacationDays());
	}
}

</pre>
<h3>Step 5: VisitorPatternDemo, our demo class, will use Employee and Visitor classes to demonstrate the use of visitor pattern.</h3>
<h3>
VisitorPatternDemo.java</h3>
<pre class="highlight">/**
 * 
 */
package com.doj.patterns.behavior.visitor;

/**
 * @author Dinesh.Rajput
 *
 */
public class VisitorPatternDemo {
	
	public static void main(String[] args) {
		
		// Setup employee collection
		Employees employees = new Employees();
		employees.add(new Clerk());
		employees.add(new Director());
		employees.add(new President());
		
		 // Employees are 'visited'
		employees.accept(new IncomeVisitor());
		employees.accept(new VacationVisitor());
	}
}

</pre>
<h3>Step 6: Let&#8217;s run this demo class and verify the output.</h3>
<pre class="highlight">Clerk Dinesh's new income: 38500.0
Director Anamika's new income: 49500.00000000001
President Arnav's new income: 71500.0

Clerk Dinesh's vacation days: 21
Director Anamika's vacation days: 23
President Arnav's vacation days: 28

</pre>
<div class="wp-post-navigation"> 
									 <div class="wp-post-navigation-pre"> 
									 <a href="https://dineshonjava.com/chain-responsibility-pattern/">Previous</a> 
									 </div> 
									 <div class="wp-post-navigation-next"> 
									 <a href="https://dineshonjava.com/memento-pattern-design-patterns-java/">Next</a> 
									 </div> 
									</div>
<script type="text/javascript">
jQuery(document).ready(function($) {
 $.post('https://dineshonjava.com/wp-admin/admin-ajax.php', {action: 'mts_view_count', id: '3465'});
});
</script>
Strategy Design Patterns We can easily create a strategy design pattern using lambda. To implement…
Decorator Pattern A decorator pattern allows a user to add new functionality to an existing…
Delegating pattern In software engineering, the delegation pattern is an object-oriented design pattern that allows…
Technology has emerged a lot in the last decade, and now we have artificial intelligence;…
Managing a database is becoming increasingly complex now due to the vast amount of data…
Overview In this article, we will explore Spring Scheduler how we could use it by…