设计模式 ~ 结构型模式 ~ 策略模式 ~ Strategy Pattern。

lyfGeek

已于 2023-02-23 23:51:49 修改

阅读量235

点赞数

分类专栏：设计模式。文章标签：策略模式设计模式结构型模式

于 2022-10-23 23:45:51 首次发布

本文链接：https://blog.csdn.net/lyfgeek/article/details/127483513

版权

设计模式。专栏收录该内容

24 篇文章 0 订阅

订阅专栏

设计模式 ~ 结构型模式 ~ 策略模式 ~ Strategy Pattern。

文章目录

- 设计模式 ~ 结构型模式 ~ 策略模式 ~ Strategy Pattern。

我们去旅游选择出行模式有很多种，可以骑自行车、可以坐汽车、可以坐火车、可以坐飞机。

作为一个程序猿，开发需要选择一款开发工具，当然可以进行代码开发的工具有很多，可以选择 Idea 进行开发，也可以使用 Eclipse 进行开发，也可以使用其他的一些开发工具。

定义。

策略模式。

该模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

结构。

策略模式的主要角色如下。

抽象策略（Strategy）类。
这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
具体策略（Concrete Strategy）类。
实现了抽象策略定义的接口，提供具体的算法实现或行为。
环境（Context）类。
持有一个策略类的引用，最终给客户端调用。

案例实现。

【eg.】促销活动。

一家百货公司在定年度的促销活动。针对不同的节日（春节、中秋节、圣诞节）推出不同的促销活动，由促销员将促销活动展示给客户。类图如下：

在这里插入图片描述
代码。

定义百货公司所有促销活动的共同接口。

package com.geek.strategy.pattern;

/**
 * 策略接口。
 *
 * @author geek
 */
public interface IStrategy {

    /**
     * show。
     */
    void show();

}

定义具体策略角色（Concrete Strategy）：每个节日具体的促销活动。

package com.geek.strategy.pattern;

/**
 * 具体策略类 A。封装算法。
 *
 * @author geek
 */
public class StrategyA implements IStrategy {

    /**
     * show。
     */
    @Override
    public void show() {
        System.out.println("买一送一。");
    }

}

package com.geek.strategy.pattern;

/**
 * 具体策略类 B。封装算法。
 *
 * @author geek
 */
public class StrategyB implements IStrategy {

    /**
     * show。
     */
    @Override
    public void show() {
        System.out.println("满 200 减 50。");
    }

}

package com.geek.strategy.pattern;

/**
 * 具体策略类 C。封装算法。
 *
 * @author geek
 */
public class StrategyC implements IStrategy {

    /**
     * show。
     */
    @Override
    public void show() {
        System.out.println("满 1000 元加一元换购任意 200 元以下商品。");
    }

}

定义环境角色（Context）：用于连接上下文，即把促销活动推销给客户，这里可以理解为销售员。

package com.geek.strategy.pattern;

import lombok.Data;

/**
 * 环境角色（Context）：用于连接上下文，即把促销活动推销给客户，这里可以理解为销售员。
 *
 * @author geek
 */
@Data
public class SalesMan {

    /**
     * 持有抽象策略角色的引用。
     * 聚合策略类对象。
     */
    private IStrategy strategy;

    public SalesMan(IStrategy strategy) {
        this.strategy = strategy;
    }

    /**
     * 向客户展示促销活动。
     */
    public void salesManShow() {
        this.strategy.show();
    }

}

package com.geek.strategy.pattern;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {

        SalesMan salesMan;

        // 春节来了，使用春节促销活动。
        salesMan = new SalesMan(new StrategyA());
        salesMan.salesManShow();

        System.out.println("～　～　～　～　～　～　～");

        // 中秋节来了，使用中秋节促销活动。
        salesMan.setStrategy(new StrategyB());
        salesMan.salesManShow();

        System.out.println("～　～　～　～　～　～　～");

        // 圣诞节来了，使用圣诞节促销活动。
        salesMan.setStrategy(new StrategyC());
        salesMan.salesManShow();
    }

}

/*
Connected to the target VM, address: '127.0.0.1:62732', transport: 'socket'
买一送一。
～　～　～　～　～　～　～
满 200 减 50。
～　～　～　～　～　～　～
满 1000 元加一元换购任意 200 元以下商品。
Disconnected from the target VM, address: '127.0.0.1:62732', transport: 'socket'

Process finished with exit code 0

 */

优缺点。

优点。
策略类之间可以自由切换。
由于策略类都实现同一个接口，所以使它们之间可以自由切换。
易于扩展。
增加一个新的策略只需要添加一个具体的策略类即可，基本不需要改变原有的代码，符合“开闭原则“。
避免使用多重条件选择语句（if else），充分体现面向对象设计思想。
缺点。
客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
策略模式将造成产生很多策略类，可以通过使用享元模式在一定程度上减少对象的数量。

使用场景。

一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。
系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。
多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。

JDK 源码解析。

Comparator 中的策略模式。在 Arrays 类中有一个 sort() 方法。

public class Arrays{



    /**
     * Sorts the specified array of objects according to the order induced by
     * the specified comparator.  All elements in the array must be
     * <i>mutually comparable</i> by the specified comparator (that is,
     * {@code c.compare(e1, e2)} must not throw a {@code ClassCastException}
     * for any elements {@code e1} and {@code e2} in the array).
     *
     * <p>This sort is guaranteed to be <i>stable</i>:  equal elements will
     * not be reordered as a result of the sort.
     *
     * <p>Implementation note: This implementation is a stable, adaptive,
     * iterative mergesort that requires far fewer than n lg(n) comparisons
     * when the input array is partially sorted, while offering the
     * performance of a traditional mergesort when the input array is
     * randomly ordered.  If the input array is nearly sorted, the
     * implementation requires approximately n comparisons.  Temporary
     * storage requirements vary from a small constant for nearly sorted
     * input arrays to n/2 object references for randomly ordered input
     * arrays.
     *
     * <p>The implementation takes equal advantage of ascending and
     * descending order in its input array, and can take advantage of
     * ascending and descending order in different parts of the the same
     * input array.  It is well-suited to merging two or more sorted arrays:
     * simply concatenate the arrays and sort the resulting array.
     *
     * <p>The implementation was adapted from Tim Peters's list sort for Python
     * (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">
     * TimSort</a>).  It uses techniques from Peter McIlroy's "Optimistic
     * Sorting and Information Theoretic Complexity", in Proceedings of the
     * Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
     * January 1993.
     *
     * @param <T> the class of the objects to be sorted
     * @param a the array to be sorted
     * @param c the comparator to determine the order of the array.  A
     *        {@code null} value indicates that the elements'
     *        {@linkplain Comparable natural ordering} should be used.
     * @throws ClassCastException if the array contains elements that are
     *         not <i>mutually comparable</i> using the specified comparator
     * @throws IllegalArgumentException (optional) if the comparator is
     *         found to violate the {@link Comparator} contract
     */
    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }


}

Arrays 就是一个环境角色类，这个 sort 方法可以传一个新策略让 Arrays 根据这个策略来进行排序。就比如下面的测试类。

package com.geek.stratyge.pattern.demo;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @author geek
 */
public class Demo {

    public static void main(String[] args) {
        Integer[] data = {12, 2, 3, 2, 4, 5, 1};
        // 降序。
        Arrays.sort(data, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
//        Arrays.sort(data, (o1, o2) -> o2 - o1);

        System.out.println("data = " + Arrays.toString(data));
        // data = [12, 5, 4, 3, 2, 2, 1]

    }

}

这里我们在调用 Arrays 的 sort(); 方法时，第二个参数传递的是 Comparator 接口的子实现类对象。所以 Comparator 充当的是抽象策略角色，而具体的子实现类充当的是具体策略角色。环境角色类（Arrays）应该持有抽象策略的引用来调用。那么，Arrays 类的 sort(); 方法到底有没有使用 Comparator 子实现类中的 compare() 方法吗？让我们继续查看 TimSort 类的 sort() 方法，代码如下。

class TimSort<T> {



    /*
     * The next method (package private and static) constitutes the
     * entire API of this class.
     */

    /**
     * Sorts the given range, using the given workspace array slice
     * for temp storage when possible. This method is designed to be
     * invoked from public methods (in class Arrays) after performing
     * any necessary array bounds checks and expanding parameters into
     * the required forms.
     *
     * @param a the array to be sorted
     * @param lo the index of the first element, inclusive, to be sorted
     * @param hi the index of the last element, exclusive, to be sorted
     * @param c the comparator to use
     * @param work a workspace array (slice)
     * @param workBase origin of usable space in work array
     * @param workLen usable size of work array
     * @since 1.8
     */
    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);
            return;
        }

        /**
         * March over the array once, left to right, finding natural runs,
         * extending short natural runs to minRun elements, and merging runs
         * to maintain stack invariant.
         */
        TimSort<T> ts = new TimSort<>(a, c, work, workBase, workLen);
        int minRun = minRunLength(nRemaining);
        do {
            // Identify next run
            int runLen = countRunAndMakeAscending(a, lo, hi, c);

            // If run is short, extend to min(minRun, nRemaining)
            if (runLen < minRun) {
                int force = nRemaining <= minRun ? nRemaining : minRun;
                binarySort(a, lo, lo + force, lo + runLen, c);
                runLen = force;
            }

            // Push run onto pending-run stack, and maybe merge
            ts.pushRun(lo, runLen);
            ts.mergeCollapse();

            // Advance to find next run
            lo += runLen;
            nRemaining -= runLen;
        } while (nRemaining != 0);

        // Merge all remaining runs to complete sort
        assert lo == hi;
        ts.mergeForceCollapse();
        assert ts.stackSize == 1;
    }



}

上面的代码中最终会跑到 countRunAndMakeAscending() 这个方法中。我们可以看见，只用了 compare(); 方法，所以在调用 Arrays.sort(); 方法只传具体 compare 重写方法的类对象就行，这也是 Comparator 接口中必须要子类实现的一个方法。


    /**
     * Returns the length of the run beginning at the specified position in
     * the specified array and reverses the run if it is descending (ensuring
     * that the run will always be ascending when the method returns).
     *
     * A run is the longest ascending sequence with:
     *
     *    a[lo] <= a[lo + 1] <= a[lo + 2] <= ...
     *
     * or the longest descending sequence with:
     *
     *    a[lo] >  a[lo + 1] >  a[lo + 2] >  ...
     *
     * For its intended use in a stable mergesort, the strictness of the
     * definition of "descending" is needed so that the call can safely
     * reverse a descending sequence without violating stability.
     *
     * @param a the array in which a run is to be counted and possibly reversed
     * @param lo index of the first element in the run
     * @param hi index after the last element that may be contained in the run.
              It is required that {@code lo < hi}.
     * @param c the comparator to used for the sort
     * @return  the length of the run beginning at the specified position in
     *          the specified array
     */
    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)
                runHi++;
            reverseRange(a, lo, runHi);
        } else {                              // Ascending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                runHi++;
        }

        return runHi - lo;
    }