Home » Java » Core Java » Strategy Design Pattern in Java – Example Tutorial

About Pankaj Kumar

Pankaj Kumar

Strategy Design Pattern in Java – Example Tutorial

Strategy pattern is one of the behavioral design pattern. Strategy pattern is used when we have multiple algorithm for a specific task and client decides the actual implementation to be used at runtime.

Strategy pattern is also known as Policy Pattern. We defines multiple algorithms and let client application pass the algorithm to be used as a parameter. One of the best example of this pattern is Collections.sort() method that takes Comparator parameter. Based on the different implementations of Comparator interfaces, the Objects are getting sorted in different ways, check this post for sorting objects in java using Java Comparable and Comparator.

For our example, we will try to implement a simple Shopping Cart where we have two payment strategies – using Credit Card or using PayPal.

First of all we will create the interface for our strategy, in our case to pay the amount passed as argument.

package com.journaldev.design.strategy;

public interface PaymentStrategy {

	public void pay(int amount);
}

Now we will have to create concrete implementations of algorithms for payment using credit/debit card or through paypal.

package com.journaldev.design.strategy;

public class CreditCardStrategy implements PaymentStrategy {

	private String name;
	private String cardNumber;
	private String cvv;
	private String dateOfExpiry;

	public CreditCardStrategy(String nm, String ccNum, String cvv, String expiryDate){
		this.name=nm;
		this.cardNumber=ccNum;
		this.cvv=cvv;
		this.dateOfExpiry=expiryDate;
	}
	@Override
	public void pay(int amount) {
		System.out.println(amount +" paid with credit/debit card");
	}

}
package com.journaldev.design.strategy;

public class PaypalStrategy implements PaymentStrategy {

	private String emailId;
	private String password;

	public PaypalStrategy(String email, String pwd){
		this.emailId=email;
		this.password=pwd;
	}

	@Override
	public void pay(int amount) {
		System.out.println(amount + " paid using Paypal.");
	}

}

Now our algorithms are ready and we can implement Shopping Cart and payment method will require input as Payment strategy.

package com.journaldev.design.strategy;

public class Item {

	private String upcCode;
	private int price;

	public Item(String upc, int cost){
		this.upcCode=upc;
		this.price=cost;
	}

	public String getUpcCode() {
		return upcCode;
	}

	public int getPrice() {
		return price;
	}

}
package com.journaldev.design.strategy;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

public class ShoppingCart {

	//List of items
	List<Item> items;

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

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

	public void removeItem(Item item){
		this.items.remove(item);
	}

	public int calculateTotal(){
		int sum = 0;
		for(Item item : items){
			sum += item.getPrice();
		}
		return sum;
	}

	public void pay(PaymentStrategy paymentMethod){
		int amount = calculateTotal();
		paymentMethod.pay(amount);
	}
}

Notice that payment method of shopping cart requires payment algorithm as argument and doesn’t store it anywhere as instance variable.

Let’s test our setup with a simple program.

package com.journaldev.design.strategy;

public class ShoppingCartTest {

	public static void main(String[] args) {
		ShoppingCart cart = new ShoppingCart();

		Item item1 = new Item("1234",10);
		Item item2 = new Item("5678",40);

		cart.addItem(item1);
		cart.addItem(item2);

		//pay by paypal
		cart.pay(new PaypalStrategy("myemail@example.com", "mypwd"));

		//pay by credit card
		cart.pay(new CreditCardStrategy("Pankaj Kumar", "1234567890123456", "786", "12/15"));
	}

}

Output of above program is:

50 paid using Paypal.
50 paid with credit/debit card

Strategy Pattern Class Diagram

Strategy-Pattern

Important Points

  • We could have used composition to create instance variable for strategies but we should avoid that as we want the specific strategy to be applied for a particular task, same is followed in Collections.sort() and Arrays.sort() method that take comparator as argument.
  • Strategy Pattern is very similar to State Pattern. One of the difference is that Context contains state as instance variable and there can be multiple tasks whose implementation can be dependent on the state whereas in strategy pattern strategy is passed as argument to the method and context object doesn’t have any variable to store it.
  • Strategy pattern is useful when we have multiple algorithms for specific task and we want our application to be flexible to chose any of the algorithm at runtime for specific task.

That’s all for Strategy Pattern in java, I hope you liked it.

 

(0 rating, 0 votes)
You need to be a registered member to rate this.
20 Comments Views Tweet it!
Do you want to know how to develop your skillset to become a Java Rockstar?
Subscribe to our newsletter to start Rocking right now!
To get you started we give you our best selling eBooks for FREE!
1. JPA Mini Book
2. JVM Troubleshooting Guide
3. JUnit Tutorial for Unit Testing
4. Java Annotations Tutorial
5. Java Interview Questions
6. Spring Interview Questions
7. Android UI Design
and many more ....
I agree to the Terms and Privacy Policy
Subscribe
Notify of
guest

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

20 Comments
Oldest
Newest Most Voted
Inline Feedbacks
View all comments
Alex
Alex
8 years ago

I Like! Thank You :-)

Mayur
Mayur
7 years ago

one of the best explanation ever seen.

Madhu
7 years ago

good one. Thanks

chandu
chandu
7 years ago

good one. thank you

Raj
Raj
7 years ago

Clarity in Explanation

jay
jay
7 years ago

Nice explanation ! .Thanks

Rose
Rose
7 years ago

Good one!!!

Neeraj
Neeraj
6 years ago

Good explanation

Salamat
Salamat
6 years ago

So what is the idea of having the pattern? I could easily go by each of classes, for example, instead of creating new interface, I will just refer to its class, say, I am paying by Paypal, I will use Paypal strategy. If I pay by card, then I use Card class. Why is interface needed at all?

Mattilla
Mattilla
6 years ago
Reply to  Salamat

This way, your class won’t be related to a specific strategy of doing something. By having an interface, you can change the strategy whenever you want, since all of the strategies implements a common interface. That’s what interfaces are for. They create a common language between two things that do not know how to relate.

sulav
sulav
6 years ago

Thank you so much. This is best explanation of strategy pattern i’ve ever studied. Helped me somehow for exams tomorrow.

sherif sadek
6 years ago

hopefully, you can elaborate a bit on your decision not to use composition?

Vivek Panday
6 years ago

Very Nice explanation with useful implementation

Vivek Panday
6 years ago

Why we are not using composition here ? I have seen some other example with composition

Arvind
6 years ago

Good Explanation of Strategy Design Pattern.

Fuhrmanator
Fuhrmanator
6 years ago

Hey! I used your example in an answer on Stack Overflow: http://stackoverflow.com/a/30424503/1168342

lakestir
lakestir
6 years ago

I believe in the above example they do not use composition because when the shopping cart is created, the payment strategy is not known. The user adds their stuff to the cart and only upon checkout does she specify a payment strategy. So why save the strategy in an instance variable?

ApacheCN
ApacheCN
5 years ago

very nice explanation, thanks

vivek Kumar
vivek Kumar
5 years ago

i am glad to say that your example helped me in a great way big THANKS!!!!!
i have been good in coding but lacked the sense of using different strategy and play around with objects.
it has been a great help.
Keep doing the good work. :)

Samuel Gómez
3 years ago

Wich software did you use for the UML diagram? by the way excellent example of this pattern. It help me a lot.