Java Design Pattern: Strategy

Strategy pattern is also called policy pattern.

Here is a story about Strategy pattern. Suppose Mike sometimes speeds when driving, but he doesn't always do that. He may be stopped by a police officer. It's possible that the police is very nice, who would let him go without any ticket or with a simple warning. (Let call this kind of police "NicePolice".) Also it's possible that he may be caught by a hard police and gets a ticket. (Let's call this kind of police "HardPolice".) He doesn't know what kind of police would stop him, until he actually gets caught, that is, run-time. This is the whole point of Strategy pattern.

Strategy Pattern Class Diagram


Strategy Pattern Java Code

Define a interface Strategy, which has one method processSpeeding()

public interface Strategy {
	//defind a method for police to process speeding case.
	public void processSpeeding(int speed);

Now we have two kinds of police officers.

public class NicePolice implements Strategy{
	public void processSpeeding(int speed) {
		System.out.println("This is your first time, be sure don't do it again!");		
public class HardPolice implements Strategy{
	public void processSpeeding(int speed) {
		System.out.println("Your speed is "+ speed+ ", and should get a ticket!");

Define a situation in which a police officer will be involved to process speeding.

public class Situation {
	private Strategy strategy;
	public Situation(Strategy strategy){
		this.strategy = strategy;
	public void handleByPolice(int speed){

Finally, try the result.

public class Main {
	public static void main(String args[]){
		HardPolice hp = new HardPolice();
		NicePolice ep = new NicePolice();
		// In situation 1, a hard officer is met
                // In situation 2, a nice officer is met
		Situation s1 = new Situation(hp);
		Situation s2 = new Situation(ep);
		//the result based on the kind of police officer.

Output is:

Your speed is 10, and should get a ticket!
This is your first time, be sure don't do it again!

You can compare this pattern with State pattern which is very similar. The major difference is that State pattern involves changing the behavior of an object when the state of the object changes while Strategy pattern is mainly about using different algorithm at different situation.

Strategy Pattern in JDK

1). Java.util.Collections#sort(List list, Comparator < ? super T > c)
2). java.util.Arrays#sort(T[], Comparator < ? super T > c)

The sort method use different Comparator in different situations. To know more about this method, check out Deep Understanding of Arrays.sort().

You may also want to check out The Difference between Comparator and Comparable.

Category >> Design Patterns Stories  
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
String foo = "bar";
  • Java Developer Central

    Nice example on the Strategy Pattern. In my blog post, I have taken a dive deep on the Pros, Cons of the pattern. I have also explained about how this pattern can be applied to avoid the need to deal with multiple conditional statements on the client side.

  • frank ho

    I confused about factory pattern and strategy pattern. I think they are the same, take your code for example, we also can use factory pattern : there is Police interface, HardPolice and NicePolice implements it separately and there is a factory to get HardPolice, NicePolice. Right? That is why I think they are the same. If that is the case, why we have factory and strategy(not just only factory or only strategy)? I searched about this confusion, someone just say factory is creational and strategy is behavioral. I still cannot understand their difference.

  • Yujia Lian

    Nice man

  • Nguyên Tánh

    perfect explanation!

  • Weidang Wang

    from good work

  • roya

    very good thanks

  • Jay

    Thank you tons for providing an example which is easy to understand/visualize.Very helpful for my learning.