Core Java

Visitor Design Pattern in Java – Example Tutorial

Visitor Pattern is one of the behavioral design pattern. Visitor pattern is used when we have to perform an operation on a group of similar kind of Objects. With the help of visitor pattern, we can move the operational logic from the objects to another class.

For example, think of a Shopping cart where we can add different type of items (Elements), when we click on checkout button, it calculates the total amount to be paid. Now we can have the calculation logic in item classes or we can move out this logic to another class using visitor pattern. Let’s implement this in our example of visitor pattern.

To implement visitor pattern, first of all we will create different type of items (Elements) to be used in shopping cart.


public interface ItemElement {

	public int accept(ShoppingCartVisitor visitor);

Notice that accept method takes Visitor argument, we can have some other methods also specific for items but for simplicity I am not going into that much detail and focusing on visitor pattern only.

Let’s create some concrete classes for different types of items.


public class Book implements ItemElement {

	private int price;
	private String isbnNumber;

	public Book(int cost, String isbn){

	public int getPrice() {
		return price;

	public String getIsbnNumber() {
		return isbnNumber;

	public int accept(ShoppingCartVisitor visitor) {
		return visitor.visit(this);



public class Fruit implements ItemElement {

	private int pricePerKg;
	private int weight;
	private String name;

	public Fruit(int priceKg, int wt, String nm){
		this.weight=wt; = nm;

	public int getPricePerKg() {
		return pricePerKg;

	public int getWeight() {
		return weight;

	public String getName(){

	public int accept(ShoppingCartVisitor visitor) {
		return visitor.visit(this);


Notice the implementation of accept() method in concrete classes, its calling visit() method of Visitor and passing itself as argument.

We have visit() method for different type of items in Visitor interface that will be implemented by concrete visitor class.


public interface ShoppingCartVisitor {

	int visit(Book book);
	int visit(Fruit fruit);

Now we will implement visitor interface and every item will have it’s own logic to calculate the cost.


public class ShoppingCartVisitorImpl implements ShoppingCartVisitor {

	public int visit(Book book) {
		int cost=0;
		//apply 5$ discount if book price is greater than 50
		if(book.getPrice() > 50){
			cost = book.getPrice()-5;
		}else cost = book.getPrice();
		System.out.println("Book ISBN::"+book.getIsbnNumber() + " cost ="+cost);
		return cost;

	public int visit(Fruit fruit) {
		int cost = fruit.getPricePerKg()*fruit.getWeight();
		System.out.println(fruit.getName() + " cost = "+cost);
		return cost;


Lets see how we can use it in client applications.


public class ShoppingCartClient {

	public static void main(String[] args) {
		ItemElement[] items = new ItemElement[]{new Book(20, "1234"),new Book(100, "5678"),
				new Fruit(10, 2, "Banana"), new Fruit(5, 5, "Apple")};

		int total = calculatePrice(items);
		System.out.println("Total Cost = "+total);

	private static int calculatePrice(ItemElement[] items) {
		ShoppingCartVisitor visitor = new ShoppingCartVisitorImpl();
		int sum=0;
		for(ItemElement item : items){
			sum = sum + item.accept(visitor);
		return sum;


When we run above program, we get following output.

Book ISBN::1234 cost =20
Book ISBN::5678 cost =95
Banana cost = 20
Apple cost = 25
Total Cost = 160

Notice that implementation if accept() method in all the items are same but it can be different, for example there can be logic to check if item is free then don’t call the visit() method at all.

Visitor Pattern Class Diagram

Class diagram for our visitor pattern implementation is:


The benefit of this pattern is that if the logic of operation changes, then we need to make change only in the visitor implementation rather than doing it in all the item classes.

Another benefit is that adding a new item to the system is easy, it will require change only in visitor interface and implementation and existing item classes will not be affected.

The drawback of visitor pattern is that we should know the return type of visit() methods at the time of designing otherwise we will have to change the interface and all of its implementations. Another drawback is that if there are too many implementations of visitor interface, it makes it hard to extend.

Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Newest Most Voted
Inline Feedbacks
View all comments
Alexandre Gam
9 years ago

Nice post man!

Visitor pattern is great but in your example what do you think about put the cost behavior in your own item? If the Book’s class knows how to calculate it? Like:

int cost = myBook.totalCost()

Its makes sense for you? Less anemic model?

Tnks for the post!

8 years ago

Nice post. Googled a lot. But your example was clear. It is the best !!. Kudos.

Some examples are so confusing in such a way that The Visitor interface got the method signature of accept() and vice versa. Also came across an actual implementation in github too [] where the visitor got the accept method, in place of visit method().

Though your example is clear and convincing , I am still exploring to confirm which implementation should be determining the behavior- Visitor or the Element(a.k.a. Visitable). ??

2 years ago

PS2 My guess: Since getLeft() returns the basic Expression, calling visit(getLeft()) would result in visit(Expression), whereas getLeft() calling visit(this) will result in another, more appropriate, visit invocation. So, accept() performs the type conversion (aka casting).

Back to top button