Strategy pattern

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

Category:

Behavioral design pattern

The problem to solve:

Suppose we have many kinds of ducks. They can fly in many ways and can quack in many ways. The trivial way to solve it is to use inheritance. There can be interfaces like Flyable and Quackable. The concrete duck implementations can implement the Flyable and Quackable interfaces. The problem here is that several ducks can have same fly behavior or quack behavior. Code will be duplicated in such cases.

Solution:

Composition is used to solve the problem. There will be interfaces for Fly behavior and Quack behavior. Concrete implementations of Fly behavior and Quack behavior will be treated as family of algorithms. The concrete duck implementations will be composed of Fly behavior and Quack behavior interfaces.

Code Example:

Head first duck example is good. Springframework guru has shown a good example also.

UML:

The following UML diagram is from Head First Design Pattern book:

Where to apply:

• Use the Strategy pattern when you want to use different variants of an algorithm within an object and be able to switch from one algorithm to another during runtime.
• Use the Strategy when you have a lot of similar classes that only differ in the way they execute some behavior.
• Use the pattern to isolate the business logic of a class from the implementation details of algorithms that may not be as important in the context of that logic.
• Use the pattern when your class has a massive conditional operator that switches between different variants of the same algorithm.

Associated design principles:

• Identify the aspects of your application that vary and separate them from what stays the same. Encapsulate what varies.
• Favor composition over inheritance.
• Program to an interface, not an implementation.

Pros:

• Prevents the conditional statements. (switch, if, else…)
• The algorithms are loosely coupled with the context entity. They can be changed/replaced without changing the context entity.
• Very easy extendable.
• Allows hot swapping algorithms at runtime.
• Isolates the code and data of the algorithms from the other classes.
• Replaces inheritance with delegation/composition

Cons:

• Clients must know existence of different strategies and a client must understand how the Strategies differ. Client must be aware of the differences between strategies to pick a proper one.
• It increases the number of objects in the application. Increases overall code complexity by creating multiple additional classes.

References:

https://www.youtube.com/watch?v=v9ejT8FO-7I&list=PLrhzvIcii6GNjpARdnO4ueTUAVR9eMBpc

https://www.tutorialspoint.com/design_pattern/strategy_pattern.htm

https://springframework.guru/gang-of-four-design-patterns/strategy-pattern/

https://www.baeldung.com/java-strategy-pattern

https://refactoring.guru/design-patterns/strategy

Lambda Expressions Best Practices

1. Prefer standard functional interfaces

We should apply the standard functional interfaces from package java.util.function whenever applicable. There are six basic functional interfaces that we can remember for convenience. The other standard functional interfaces can be derived the basic ones easily.

* The above table is taken from book Effective Java 3rd edition

Here an example applying Predicate and Consumer:

  public static void main(String[] args) {
    List personList = Arrays.asList(
        new Person("Sajib", "Amin", 34),
        new Person("Salman", "Rishad", 34),
        new Person("Shafiul", "Hasan", 34),
        new Person("Anitam", "Das", 26),
        new Person("Khaled", "Sazzad", 26));
    
    Collections.sort(personList, (p1, p2) -> 
     p1.getLastName().compareTo(p2.getLastName()));
    printConditionally(personList, 
     p -> p.getFirstName().startsWith("S"),
        p -> System.out.println(p.getFirstName()));
  }

  private static void printConditionally(List personList, 
   Predicate predicate, Consumer consumer) {
    for (Person p : personList) {
          if (predicate.test(p)) {
              consumer.accept(p);
         }
    }
  }

2. Use the @FunctionalInterface annotation

We should annotate our custom functional interfaces with @FunctionalInterface. If we don’t annotate, other developers can accidentally add more abstract methods and break the conditions of using it as a functional interface.

3. Don’t overuse default methods in functional interfaces

We should not make excessive use of default methods in a functional interface. Excessive use can introduce situations where default method with same name will exist in two separate interfaces and another interface is trying to extend them both.

Adding too many default methods to the interface is not a very good architectural decision. It is should be viewed as a compromise, only to be used when required, for upgrading existing interfaces without breaking backward compatibility.

4. Prefer lambdas to anonymous classes

A functional interface can be implemented using an anonymous inner class. But, that should be avoided as much as possible. Lambda expression should be used in such cases. For example, here is an anonymous inner class implementation of Comparator:

    Collections.sort(wordList, new Comparator() {
          @Override
          public int compare(String s1, String s2) {
                return s1.compareTo(s2);
          }
    });

It should be replaced with lambda expression like

    Collections.sort(wordList, (s1, s2) -> s1.compareTo(s2));

5. Avoid overloading methods with functional interfaces as parameters

When functional interfaces are used as parameters in method, we should avoid overloaded use of them. Method with different name can be used to avoid collision. A good example is available here.

6. Don’t treat lambda expressions as inner classes

When we instantiate an inner class, it creates a new scope. We can overwrite local variables from the enclosing scope by instantiating new local variables with the same names. We can also use the keyword this inside our inner class as a reference to its instance.

Lambda expression does not create its own scope, it relies on the enclosing scope. We can’t overwrite variables from the enclosing scope inside the lambda’s body. In this case, the keyword this is a reference to an enclosing instance. A good example is available here.

7. Use effectively final variables

Lambda expressions can access final variables only. Accessing a non-final variable inside lambda expressions will cause the compile-time error. However, we do not need to mark the variable with final keyword. As long as the variable is assigned value only once, compiler will treat it as effectively final.

8. Keep lambda expressions short and self-explanatory

a) Avoid blocks of code in lambda’s body

One liner is ideal for lambda expression. Large block of code can be encapsulated inside a method in some cases.

b) Avoid specifying parameter types

Parameter types are usually omitted. (a, b) -> should be used instead of (String a, String b) ->

c) Avoid parentheses around a single parameter

For single parameter, use of parentheses is unnecessary. a -> should be used instead if (a) ->

d) Avoid return statement and braces

Braces and return statements are optional in one liner lambda expression. So, a -> a.toLowerCase() should be used instead of a -> {return a.toLowerCase()}

e) Use method references

Method reference is already discussed in previous post. It is recommended to replace lambda expression with method reference whenever it is applicable.

References:

https://www.baeldung.com/java-8-lambda-expressions-tips

https://www.youtube.com/watch?v=WcLum7g6ImU&list=PLqq-6Pq4lTTa9YGfyhyW2CqdtW9RtY-I3&index=19

https://medium.com/@gelopfalcon/best-practices-when-you-use-lambda-expressions-in-java-f51e96d44b25

http://tutorials.jenkov.com/java/lambda-expressions.html

Lamda Expressions Concepts

Lambda expression leverages functional programming in Java. Lambda expression contains the implementation of a single function within the instance of an interface. The close similarity of lambda expression is anonymous inner class implementation of an interface.

Lambda expressions implement functional interfaces. A functional interface is an interface that can contain only one abstract method. A functional interface can however contain several default methods and static methods.

Let's define one functional interface like the following:

  @FunctionalInterface
  public interface Greeting {
    public void sayGreeting(String message);
  }

Here use of annotation @FunctionalInterface is recommended since it enforces to use only one abstract method. Lets first implement it with anonymous inner class:

    Greeting greetingImpl = new Greeting() {
          @Override
          public void sayGreeting(String message) {
                System.out.println(message);
          }
    };
    greetingImpl.sayGreeting("Hello from Anonymous inner class.");

Using lambda expression for doing the same task will make the code shorter and cleaner.

    Greeting greetingLambda = message -> System.out.println(message);
    greetingLambda.sayGreeting("Hello from Lambda expression");

Lambda expression syntax:

(argument-list) -> {body}

Java lambda expression is consisted of three parts:

• Argument-list: It can be empty or non-empty.
• Arrow-token: It is used to link arguments-list and body of expression.
• Body: It contains expressions and statements for lambda expression.

Type declaration can be included

MathOperation addition = (int a, int b) -> a + b;

Type declaration can be omitted

MathOperation subtraction = (a, b) -> a - b;

Lambda expression can contain return statement along with curly braces

    MathOperation multiplication = (int a, int b) -> {
          return a * b;
    };

Lambda as method argument:

We can pass both lambda expression as method arguments. For example, let’s consider a method:

  public static void callWithLambda(Greeting greeting, String message) {
    greeting.sayGreeting(message);
  }

We can call the above method like the following:

    callWithLambda(message -> System.out.println(message), 
          "Lambda argument pass test1");

Generic Functional Interfaces

Functional interfaces can be generic.

@FunctionalInterface
interface GenericInterface {
  void test(T param);
}

Lambda expression can associate with generic functional interfaces.

    GenericInterface genericInterface1 = (str) -> System.out.println(str);
    genericInterface1.test("Test generic interface with type string");
    
    GenericInterface genericInterface2 = (i) -> System.out.println(i);
    genericInterface2.test(5);

Method Reference:

There is a shortcut of using lambda expression. That is called method reference. It will make code even shorter. Double colon (::) is used as the syntax of method reference.

Greeting greetingLambda = message -> System.out.println(message);

Equivalent use of method reference

    Greeting greetingMethodReference = System.out::println;
    greetingMethodReference.sayGreeting("Hello from method reference");

Can be used as method argument also:

callWithLambda(System.out::println, "Lambda argument pass test2");

We can reference the following types of methods:

• Static method:

  public static void defaultGeeting(String message) {
      System.out.println(message);
    }
  callWithLambda(LambdaTest::defaultGeeting, "Static method reference");
  

• Instance method on parameter objects:

  Finder finder = (s1, s2) -> s1.indexOf(s2);
  

  By using method reference

  Finder finder = String::indexOf;
  

• Instance method:

  StringConverter stringConverter = new StringConverter();
  
  Deserializer des = stringConverter::convertToInt;
  

• Constructor:
  It is possible to refer a constructor of a class. We can do that by using ::new as like the following example. Here the functional interface is like

      public interface Factory {
              public String create(char[] val);
      }
  

  Using regular lambda

  Factory factory = chars -> new String(chars);
  

  Using constructor reference

  Factory factory = String::new;
  

References:

• https://www.youtube.com/watch?v=gpIUfj3KaOc&list=PLqq-6Pq4lTTa9YGfyhyW2CqdtW9RtY-I3
• https://www.javatpoint.com/java-lambda-expressions
• https://medium.freecodecamp.org/learn-these-4-things-and-working-with-lambda-expressions-b0ab36e0fffc
• https://www.baeldung.com/java-8-lambda-expressions-tips
• http://tutorials.jenkov.com/java/lambda-expressions.html