17, Strategy mode

Posted by murtuza.hasan.13 on Sun, 24 Oct 2021 19:32:33 +0200

0. Ma Xian inspirational

Human beings are great because of their dreams. Action is the beginning of dreams.

1. General

First look at the pictures below. There are many travel modes for us to travel. We can ride a bike, take a car, take a train and take a plane.

As a program ape, you need to choose a development tool for development. Of course, there are many tools for code development. You can choose Idea for development, eclipse for development, or some other development tools.


This pattern defines a series of algorithms and encapsulates each algorithm so that they can be replaced with each other, and the change of the algorithm will not affect the customers using the algorithm. The policy pattern belongs to the object behavior pattern. It separates the responsibility of using the algorithm from the implementation of the algorithm by encapsulating the algorithm, and delegates it to different objects to manage these algorithms.

2. Structure

The main roles of the policy mode are as follows:

  • Abstract Strategy class: This is an abstract role, usually implemented by an interface or abstract class. This role gives the interfaces required for all specific policy classes.
  • Concrete Strategy class: implements the interface of abstract policy definition and provides specific algorithm implementation or behavior.
  • Context class: holds a reference to a policy class, which is finally called to the client.

3. Case realization

Promotion activities

A department store's annual promotion. Different promotional activities are launched for different festivals (Spring Festival, Mid Autumn Festival and Christmas), and the promoters show the promotional activities to customers. Class diagram is as follows:

The code is as follows:

Define the common interface for all promotional activities of the department store

public interface Strategy {
    void show();

Define Concrete Strategy: specific promotional activities for each festival

//Promotional activities for the Spring Festival A
public class StrategyA implements Strategy {

    public void show() {
        System.out.println("Buy 1 Get 1 FREE");

//Promotional activities for the Mid Autumn Festival B
public class StrategyB implements Strategy {

    public void show() {
        System.out.println("50 yuan less than 200 yuan");

//Promotion for Christmas C
public class StrategyC implements Strategy {

    public void show() {
        System.out.println("Over 1000 yuan plus 1 yuan for any commodity below 200 yuan");

Define environment role (Context): used to connect the Context, that is, sell promotional activities to customers, which can be understood as salesperson here

public class SalesMan {                        
    //Holds a reference to an abstract policy role                              
    private Strategy strategy;                 
    public SalesMan(Strategy strategy) {       
        this.strategy = strategy;              
    //Show promotions to customers                                
    public void salesManShow(){                

4. Advantages and disadvantages

1. Advantages:

  • Policy classes can be switched freely

    Since the policy classes all implement the same interface, they can switch freely.

  • Easy to expand

    To add a new policy, you only need to add a specific policy class, basically do not need to change the original code, and comply with the "opening and closing principle"“

  • Avoid using multiple conditional selection statements (if else) and fully reflect the idea of object-oriented design.

2. Disadvantages:

  • The client must know all policy classes and decide which policy class to use.
  • The policy pattern will result in many policy classes. You can reduce the number of objects to a certain extent by using the meta pattern.

5. Usage scenario

  • When a system needs to dynamically select one of several algorithms, each algorithm can be encapsulated into a policy class.
  • A class defines multiple behaviors, and these behaviors appear in the form of multiple conditional statements in the operation of this class. Each conditional branch can be moved into their respective policy class to replace these conditional statements.
  • Each algorithm in the system is completely independent of each other, and it is required to hide the implementation details of the specific algorithm from the customer.
  • When the system requires that the customer using the algorithm should not know the data it operates, the policy pattern can be used to hide the data structure related to the algorithm.
  • Multiple classes only have different behaviors. You can use the policy mode to dynamically select the specific behavior to be executed at run time.

6.JDK source code analysis

Policy pattern in Comparator. There is a sort() method in the Arrays class, as follows:

public class Arrays{
    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
                TimSort.sort(a, 0, a.length, c, null, 0, 0);

Arrays is an environment role class. This sort method can pass a new policy to let arrays sort according to this policy, such as the following test class.

public class demo {
    public static void main(String[] args) {

        Integer[] data = {12, 2, 3, 2, 4, 5, 1};
        // Implement descending sort
        Arrays.sort(data, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
        System.out.println(Arrays.toString(data)); //[12, 5, 4, 3, 2, 2, 1]

Here, when we call the sort method of Arrays, the second parameter passes the sub implementation class object of the Comparator interface. Therefore, Comparator acts as an abstract policy role, and the specific sub implementation class acts as a specific policy role. Environment role class (Arrays) It should be called with a reference to the abstract policy. So, does the sort method of the Arrays class use the compare() method in the Comparator subclass? Let's continue to check the sort() method of the TimSort class. The code is as follows:

class TimSort<T> {
    static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                         T[] work, int workBase, int workLen) {
        assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

        int nRemaining  = hi - lo;
        if (nRemaining < 2)
            return;  // Arrays of size 0 and 1 are always sorted

        // If array is small, do a "mini-TimSort" with no merges
        if (nRemaining < MIN_MERGE) {
            int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
            binarySort(a, lo, hi, lo + initRunLen, c);
    private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,Comparator<? super T> c) {
        assert lo < hi;
        int runHi = lo + 1;
        if (runHi == hi)
            return 1;

        // Find end of run, and reverse range if descending
        if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
            reverseRange(a, lo, runHi);
        } else {                              // Ascending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)

        return runHi - lo;

The above code will eventually run to the countrunandmakescreening() method. We can see that only the compare method is used, so when calling the Arrays.sort method, only the class object of the specific compare rewriting method is passed. This is also a method that must be implemented by subclasses in the Comparator interface.

This blog comes from the summary of dark horse programmer's video tutorial and the arrangement of notes. It is only for learning and communication. It should not be used for commercial purposes. If there is infringement, please contact the blogger to delete it. Blogger QQ: 194760901

Topics: Java Design Pattern