Strategy Designing Inward Coffee Amongst Example

Can you lot tell me whatever pattern pattern which you lot receive got used of late inwards your project, except Singleton? This is i of the pop questions from diverse Java interviews inwards recent years. I think, this genuinely motivated many Java programmers to explore to a greater extent than pattern patterns together with genuinely expect at original 23 patterns introduced yesteryear GOF. Strategy pattern is i of the useful patterns you lot tin refer piece answering such question. It's real pop together with at that spot are lots of existent globe scenario where Strategy pattern is real handy. Many programmers inquire me what is the best means to larn pattern pattern, I tell you lot commencement demand to notice how other people utilisation it together with for that you lot demand to expect at the opened upwards source libraries you lot utilisation inwards your daily task. JDK API is i such library I utilisation on daily solid soil together with that's why when I explore novel algorithms, pattern pattern, I commencement search JDK for their usage.

The strategy pattern has industrial plant life its house inwards JDK, together with you lot know what I hateful if you lot receive got sorted ArrayList inwards Java. Yes, combination of Comparator, Comparable, together with Collections.sort() method are i of the best existent globe event of Strategy pattern pattern.

To empathise it more, let's commencement notice out what is Strategy pattern? The commencement clue is the call itself.  The strategy pattern defines a household unit of measurement of related algorithms e.g. sorting algorithms similar bubble sort, quicksort, insertion sort  together with merge sort, or compression algorithm e.g. zip, gzip, tar, jar, encryption algorithm e.g. doc 5, AES etc together with lets the algorithm vary independently from clients that utilisation it.

For example, you lot tin utilisation Strategy pattern to implement a method which variety numbers together with allows the customer to conduct whatever sorting algorithm at runtime, without modifying client's code. So essentially Strategy pattern provides flexibility, extensible together with choice. You should take in using this pattern when you lot demand to select an algorithm at runtime.

In Java, a strategy is ordinarily implemented yesteryear creating a hierarchy of classes that extend from a base of operations interface known every bit Strategy. In this tutorial, nosotros volition larn roughly interesting things almost Strategy pattern yesteryear writing a Java computer programme together with demonstrating how it add together value to your code. See Head First pattern pattern for to a greater extent than details on this together with other GOF patterns. This mass is too updated to Java SE 8 on its tenth anniversary.

What is Intent of Strategy Pattern

While learning a novel pattern, most of import affair to empathise is intent, motivation. Why? because 2 pattern pattern tin receive got the same construction but their intent could endure totally different. Even, i of a proficient event of this theory is State together with Strategy pattern.

If you lot expect at UML diagram of these 2 patterns they expect identical but the intent of State pattern is to facilitate nation transition piece the intent of Strategy pattern is to alter the demeanour of a shape yesteryear changing internal algorithm at runtime without modifying the shape itself.  That's why Strategy pattern is utilisation of behavioral patterns inwards GOF's original list.

You tin correlate Strategy pattern amongst how people utilisation a dissimilar strategy to bargain amongst a dissimilar situation, for event if you lot are confronted amongst a province of affairs together with then you lot volition either bargain amongst it or run away 2 dissimilar strategies.

If you lot receive got non read already together with then you lot should too read the Head First Design pattern, i of the best books to larn practical utilisation of pattern pattern inwards Java application. Most of my cognition of GOF pattern patterns are attributed to this book. It's been 10 years since the mass was commencement released, thankfully it is right away updated to comprehend Java SE 8 every bit well.

Terminology together with Structure of Strategy Pattern

This pattern has 2 principal component, Strategy interface, together with Context class. Strategy interface declares the type of algorithm, it tin endure abstract shape or interface. For example, you lot tin define a Strategy interface amongst method move(), right away this displace becomes strategy together with dissimilar pieces inwards a game of chess tin implement this method to define their moving strategy.

For example, Rook volition displace solely horizontal or vertical, Bishop volition displace diagonally, Pawn volition displace i jail cellular telephone at a fourth dimension together with Queen tin displace horizontal, vertical together with diagonally.  The dissimilar strategy employed yesteryear dissimilar pieces for displace are an implementation of Strategy interface together with the code which moves pieces is our Context class.

When nosotros alter piece, nosotros don't demand to alter Context class. If a novel slice is added, together with then too your code which takes attention of moving pieces volition non require to endure modified.

Here is UML diagram of Strategy pattern :

Open Closed pattern principle, which says that novel demeanour is added yesteryear writing novel code non yesteryear modifying tried together with tested former code.

If you lot utilisation Strategy pattern, you lot volition endure adding a novel Strategy yesteryear writing a novel shape which but demand to implement Strategy interface. Because of opened upwards shut regulation violation, nosotros cannot utilisation Enum to implement Strategy pattern.

Though it has roughly payoff together with suits good if you lot know major algorithm good inwards advance but you lot demand to modify your Enum shape to add together novel algorithms which is violation of opened upwards shut principle. To larn to a greater extent than encounter here.

Real World Examples of Strategy Design Pattern

JDK has pair of examples of this pattern, commencement is Collection.sort(List, Comparator) method, where Comparator is Strategy together with Collections.sort() is Context. Because of this pattern your variety method tin variety whatever object, the object which doesn't exists when this method was written. As long as, Object volition implement Comparator interface (Strategy interface), Collections.sort() method volition variety it.

Another event is  java.util.Arrays#sort(T[], Comparator < ? super T > c) method which similar to Collections.sort() method, except demand array inwards house of List.

You tin too encounter classic Head First Design pattern mass for to a greater extent than existent globe examples of Strategy together with other GOF patterns.

Strategy Pattern Implementation inwards Java

Here is unproblematic Java computer programme which implements Strategy pattern pattern. You tin utilisation this sample code to larn together with experiment amongst this pattern. The event is real simple, all it does is define a strategy interface for sorting algorithms together with utilisation that interface on a method called arrange. This method tin conform object inwards increasing or decreasing order, depending upon how you lot implement. In fellowship to conform object, you lot demand sorting together with this is provided yesteryear Strategy pattern. This allows you lot to conduct whatever algorithm to variety your object.

/**  * Java Program to implement Strategy pattern pattern inwards Java.   * Strategy pattern allows you lot to render dissimilar strategy without  * changing the Context class, which uses that strategy. You can  * too innovate novel sorting strategy whatever time. Similar example  * is Collections.sort() method, which convey Comparator or Comparable  * which is genuinely a Strategy to compare objects inwards Java.  *   * @author WINDOWS 8  */  public class Test {      public static void main(String args[]) throws InterruptedException {                  // nosotros tin provide whatever strategy to create the sorting          int[] var = {1, 2, 3, 4, 5 };         Context ctx = new Context(new BubbleSort());         ctx.arrange(var);                  // nosotros tin alter the strategy without changing Context class         ctx = new Context(new QuickSort());         ctx.arrange(var);     }  }  interface Strategy {     public void sort(int[] numbers); }  class BubbleSort implements Strategy {      @Override     public void sort(int[] numbers) {         System.out.println("sorting array using bubble variety strategy");      }  }  class InsertionSort implements Strategy {      @Override     public void sort(int[] numbers) {         System.out.println("sorting array using insertion variety strategy");      } }  class QuickSort implements Strategy {      @Override     public void sort(int[] numbers) {         System.out.println("sorting array using quick variety strategy");      } }  class MergeSort implements Strategy {      @Override     public void sort(int[] numbers) {         System.out.println("sorting array using merge variety strategy");      } }  class Context {     private final Strategy strategy;      public Context(Strategy strategy) {         this.strategy = strategy;     }      public void arrange(int[] input) {         strategy.sort(input);     } }  Output sorting array using bubble variety strategy sorting array using quick variety strategy

Things to Remember almost Strategy Pattern inwards Java

Now let's revise what you lot receive got larn inwards this tutorial almost strategy pattern pattern  :

1) This pattern defines a laid of related algorithm together with encapsulate them inwards separated classes, together with allows customer to conduct whatever algorithm at run time.

2) It allows to add together novel algorithm without modifying existing algorithms or context class, which uses algorithm or strategies.

3) Strategy is a behavioral pattern inwards GOF list.

4) Strategy pattern is based upon Open Closed pattern regulation of SOLID Principles of Object Oriented Design.

5) Collections.sort() together with Comparator interface is existent globe event of Strategy pattern.


That's all almost how to implement Strategy pattern inwards Java. For your exercise write a Java computer programme to implement encoding together with allow customer to conduct betwixt dissimilar encoding algorithm e.g. base of operations 64. This pattern is too real useful when you lot receive got province of affairs where you lot demand to acquit differently depending upon type e.g. writing a method to procedure trades, if trades is of type NEW,  it volition endure processed differently, if it is CANCEL together with then it volition endure processed differently together with if its AMEND together with then too it volition endure handled differently, but retrieve each fourth dimension nosotros demand to procedure trade.

Further Learning
Design Pattern Library
From 0 to 1: Design Patterns - 24 That Matter - In Java
Java Design Patterns - The Complete Masterclass