（02）策略模式

概念

如一个洗衣机有标准、快洗、浸洗、大件等等不同清洗策略。我们选择不同的策略时，洗衣机就以具体的策略去执行。我们无需关心策略的具体逻辑，只需要指定某个策略执行即可。

策略其实就是定义各种算法（如洗衣机各种清洗策略），将每个算法封装起来，当需要哪个算法时，就指定哪个算法执行。我们使用算法时，无需关心算法的具体实现，只需指定具体算法即可。

实现方式

示例一

/**
 * 策略
 */
public class Demo {
    public static void main(String[] args) {
        String msg = "xxxxxx";
        saveLog(msg, "DbLog");
        saveLog(msg, "FileLog");
        saveLog(msg, new DbLog());// 保存时，指定存储到数据库策略
        saveLog(msg, new FileLog());// 保存时，指定存储到文件策略
    }

    // 不使用策略模式，如果 logType 越多，则 if...else 也会越多
    public static void saveLog(String msg, String logType) {
        if ("DbLog".equals(logType)) {
            System.out.println("不使用策略模式：现在把 '" + msg + "' 记录到db中");
        } else if ("FileLog".equals(logType)) {
            System.out.println("不使用策略模式：现在把 '" + msg + "' 记录到file中");
        }
    }

    // 使用策略模式，只需一行代码搞定，无需 if...else。使用多态的方式解决问题
    public static void saveLog(String msg, LogStrategy logStrategy) {
        logStrategy.log(msg);
    }
}

// 日志策略接口
interface LogStrategy {
    void log(String msg);
}

// 具体策略：把日志记录到数据库策略
class DbLog implements LogStrategy {
    public void log(String msg) {
        System.out.println("策略模式：现在把 '" + msg + "' 记录到db中");
    }
}

// 具体策略：把日志记录到文件策略
class FileLog implements LogStrategy {
    public void log(String msg) {
        System.out.println("策略模式：现在把 '" + msg + "' 记录到file中");
    }
}

不使用策略模式：现在把 'xxxxxx' 记录到db中
不使用策略模式：现在把 'xxxxxx' 记录到file中
策略模式：现在把 'xxxxxx' 记录到db中
策略模式：现在把 'xxxxxx' 记录到file中

示例二

java 中的比较器，就属于策略模式

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

/**
 * 策略
 */
public class Demo {
    public static void main(String[] args) {
        String[] arr = {"abc", "a", "ab"};
        Arrays.sort(arr, new StrLenRiseCompare());
        System.out.println(Arrays.toString(arr));
    }
}

class StrLenRiseCompare implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        if (o1.length() < o2.length()) return -1;
        else if (o1.length() > o2.length()) return 1;
        else return 0;
    }
}

[a, ab, abc]

示例三

模仿Java比较器，实现自己的比较器

/**
 * 策略
 */
public class Demo {
    public static void main(String[] args) {
        String[] arr = {"abc", "a", "abcd", "ab"};

        sort(arr, new StrLenRiseCompare());
        System.out.println(Arrays.toString(arr)); // [a, ab, abc, abcd]

        sort(arr, new StrLenDeclineCompare());
        System.out.println(Arrays.toString(arr)); // [abcd, abc, ab, a]
    }

    public static <T> void sort(T[] arr, MyComparator<T> comparator) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                int compareto = comparator.compare(arr[i], arr[j]);
                if (compareto == 1) {
                    T temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
}

interface MyComparator<T> {
    int compare(T o1, T o2);
}

class StrLenRiseCompare implements MyComparator<String> {
    @Override
    public int compare(String o1, String o2) {
        if (o1.length() < o2.length()) return -1;
        else if (o1.length() > o2.length()) return 1;
        else return 0;
    }
}

[a, ab, abc, abcd]
[abcd, abc, ab, a]