<p><strong>Strategy Pattern</strong> is one of the <strong><a href="https://dineshonjava.com/behavioral-design-pattern/">behavioral design patterns</a></strong>. The strategy pattern, in computer programming, is also known as policy pattern. It makes it possible to select an algorithm at run-time. The strategy pattern is responsible for defining a family of algorithms, encapsulating every algorithm and making the algorithms capable of interchanging themselves within the family of algorithms.</p>
<p>The strategy pattern was added in the highly influential book, Design Patterns by Gamma et.al. This book made popular the concept of design patterns usage in computer programming; object-oriented programming to design, versatile and reusable object-oriented software.</p>
<h2>Strategy Pattern</h2>
<div style="text-align: left;">
<blockquote><p><strong>According to the Gang of Four:</strong></p>
<div style="text-align: left;">Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.</div>
</blockquote>
</div>
<p><strong>For example,</strong> if a class were to perform a validation on incoming data, it could approach the strategy pattern in order to select a validation algorithm, on account for the type of the data received, the source by which the data was received, the choice of the user or any other differentiating factors. These factors are not recognized until run-time and may additionally require completely different validation to be performed. It is possible for the different validating objects in the system or even different regions of the system, to be able to use the validation algorithms or strategies because the strategies are encased separately from the validating objects. This can be done without having to duplicate the code.</p>
<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/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>Implementing the Strategy Pattern</h2>
<p>To implement the strategy pattern, the most important requirement is to be able to hold a reference to the same code in the data structure and be able to retrieve it. There are different mechanisms to achieve this, which are; native function pointer, the first class function, by gaining access to the internal storage of the code of implementation language using reflection method, classes or class instances in object-oriented programming.</p>
<p>To design, versatile and reusable object-oriented software, there is <strong><a href="https://dineshonjava.com/design-patterns_25/">23 well-known Gang of Four (GoF) design patterns</a></strong>, the strategy behavioral pattern is one of them. There are some problems that strategy pattern caters. A class is supposed to be configured using an algorithm, it is not supposed to be implementing an algorithm explicitly. An algorithm must be chosen and interchanged at a run-time. Algorithms are defined as a method or procedure which takes in an input value, operate some operations on the value, perform some steps on it and produces an output value. Generally, it is said to be a piece of code which performs appropriate operations.</p>
<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 Patterns</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"><strong>Amazon</strong></a> and <a href="https://www.packtpub.com/application-development/spring-5-design-patterns" target="_blank" rel="noopener"><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 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"><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>To implement an algorithm explicitly in the class which uses the algorithm, it creates inflexibility, because it tightly couples the class to a certain algorithm at compile-time and in turn makes it difficult, almost impossible to alter the algorithm later, without having to alter the class. Due to this problem, the class is no longer reusable for any other algorithm that is to be used. The strategy pattern is responsible for defining a separate object which encloses an algorithm, which means it defines an interface for executing an algorithm. It is also able to define classes which perform the algorithms in various ways. A strategy object is assigned an algorithm at run-time by a Class.</p>
<h2>Benefits of the Strategy Pattern:</h2>
<p>There are following lists the benefits of using the Strategy pattern:</p>
<ul>
<li>This pattern allows you to create the related classes with difference their behavior.</li>
<li>This pattern provide a group of interchangable algorithms.</li>
<li>It provides an alternate of subclassing</li>
<li>It reduce complexity because it defines each behavior in its own class, so it eliminates conditional statements.</li>
</ul>
<h2>UML Class Diagram for Strategy Design Pattern</h2>
<p>Let&#8217;s see the following UML diagram is showing the all components of Strategy design pattern:</p>
<p><img class="aligncenter wp-image-3312 size-full" src="https://dineshonjava.com/wp-content/uploads/2017/12/strategy.gif" alt="Strategy Pattern Design Patterns in Java" width="437" height="164" /></p>
<h3>Strategy</h3>
<p>It is an interface, it is common to all strategies or algorithms, Suppose a SortStrategy in the application.</p>
<h3>ConcreteStrategy</h3>
<p>It is implementation of Strategy interface, it implements the algorithm using the Strategy. Suppose QuickSort, MergeSort etc are implementation of SortStrategy interface.</p>
<h3>Context</h3>
<p>It is a class that configured with a ConcreteStrategy object. Its behavior depedends on the state of Strategy. Suppose if you change QuickSort to MergeSort then behavior of context object changed accordingly as like SortedList.</p>
<h2>Example for Strategy Design Pattern Implementation</h2>
<p>This real-world code demonstrates the Strategy pattern which encapsulates sorting algorithms in the form of sorting objects. This allows clients to dynamically change sorting strategies including Quicksort, Shellsort, and Mergesort.</p>
<h3>Step 1: Create an interface.<br />
SortStrategy.java</h3>
<pre class="highlight">/** 
 * 
 */ 
package com.doj.patterns.strategy.state; 
 
import java.util.List; 
 
/** 
 * @author Dinesh.Rajput 
 * 
 */ 
public interface SortStrategy { 
	 
	void sort(List list); 
	 
} 
</pre>
<h3>Step 2: Create concrete classes implementing the same interface.<br />
QuickSort.java</h3>
<pre class="highlight">/** 
 * 
 */ 
package com.doj.patterns.strategy.state; 
 
import java.util.Comparator; 
import java.util.List; 
 
/** 
 * @author Dinesh.Rajput 
 * 
 */ 
public class QuickSort implements SortStrategy { 
 
	@Override 
	public void sort(List list) { 
		//Implementing quick sort here 
		list.sort(new Comparator() { 
			@Override 
			public int compare(String o1, String o2) { 
				return o1.compareTo(o2); 
			} 
			 
		}); 
		System.out.println("QuickSorted list "); 
	} 
 
} 
</pre>
<h3>MergeSort.java</h3>
<pre class="highlight">/** 
 * 
 */ 
package com.doj.patterns.strategy.state; 
 
import java.util.List; 
 
/** 
 * @author Dinesh.Rajput 
 * 
 */ 
public class MergeSort implements SortStrategy { 
 
	@Override 
	public void sort(List list) { 
		//Implement merge sort here 
		System.out.println("MergeSorted list "); 
	} 
 
} 
 
</pre>
<h3>ShellSort.java</h3>
<pre class="highlight">/** 
 * 
 */ 
package com.doj.patterns.strategy.state; 
 
import java.util.List; 
 
/** 
 * @author Dinesh.Rajput 
 * 
 */ 
public class ShellSort implements SortStrategy { 
 
	@Override 
	public void sort(List list) { 
		//Implement ShellSort Here 
		System.out.println("ShellSorted list "); 
	} 
 
} 
 
</pre>
<h3>Step 3: Create Context Class.<br />
SortedList.java</h3>
<pre class="highlight">/** 
 * 
 */ 
package com.doj.patterns.strategy.state; 
 
import java.util.ArrayList; 
import java.util.List; 
 
/** 
 * @author Dinesh.Rajput 
 * 
 */ 
public class SortedList { 
	private List _list = new ArrayList<;>;(); 
 private SortStrategy _sortstrategy; 
 
 public void SetSortStrategy(SortStrategy sortstrategy){ 
 	this._sortstrategy = sortstrategy; 
 } 
 
 public void add(String name){ 
 	_list.add(name); 
 } 
 
 public void sort(){ 
 	_sortstrategy.sort(_list); 
 	// Iterate over list and display results 
 	for(String name : _list) { 
 		System.out.println(" " + name); 
 	} 
 	System.out.println(); 
 } 
} 
</pre>
<h3>Step 4: Use the Context to see change in behavior when it changes its Strategy.<br />
StrategyPatternDemo.java</h3>
<pre class="highlight">/** 
 * 
 */ 
package com.doj.patterns.strategy.state; 
 
/** 
 * @author Dinesh.Rajput 
 * 
 */ 
public class StrategyPatternDemo { 
 
	/** 
	 * @param args 
	 */ 
	public static void main(String[] args) { 
		// Two contexts following different strategies 
		SortedList userRecords = new SortedList(); 
		userRecords.add("Dinesh"); 
		userRecords.add("Arnav"); 
		userRecords.add("Anamika"); 
		userRecords.add("Vinesh"); 
		userRecords.add("Adesh"); 
 
		userRecords.SetSortStrategy(new QuickSort()); 
		userRecords.sort(); 
 
		userRecords.SetSortStrategy(new ShellSort()); 
		userRecords.sort(); 
 
		userRecords.SetSortStrategy(new MergeSort()); 
		userRecords.sort(); 
	} 
} 
 
</pre>
<h3>Step 5: Let&#8217;s run the demo class and verify the output.</h3>
<pre class="highlight">QuickSorted list 
 Adesh 
 Anamika 
 Arnav 
 Dinesh 
 Vinesh 
 
ShellSorted list 
 Adesh 
 Anamika 
 Arnav 
 Dinesh 
 Vinesh 
 
MergeSorted list 
 Adesh 
 Anamika 
 Arnav 
 Dinesh 
 Vinesh 
 
 
</pre>
<div class="wp-post-navigation"> 
									 <div class="wp-post-navigation-pre"> 
									 <a href="https://dineshonjava.com/state-pattern/">Previous</a> 
									 </div> 
									 <div class="wp-post-navigation-next"> 
									 <a href="https://dineshonjava.com/template-method-pattern-design-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: '3311'});
});
</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…