用实例理解策略模式

策略模式( Strategy )，通常可以被用来优化多重嵌套的条件判断逻辑中，解耦代码。

多条件判断

假设有如下需求，给两个字符串a，b，经过一些处理，返回b的值，其中b的值有如下要求：

b为空且a中包含[0、1、2、3、4]中任意一个，则b的值即为所包含的这个值，如果不包含，则返回空字符串

b为0 且a中包含[1、2、3、4]中任意一个，则b的值即为所包含的这个值，如果不包含，则返回空字符串

b为1 且a中包含[2、3、4]中任意一个，则b的值即为所包含的这个值，如果不包含，则返回空字符串

如果按照这个规则，直接写代码的话可能会是如下写法

public static String getString(String a, String b) {
    if ("".equals(b)) {
        if (a.contains("0")) {
            b = "0";
        } else if (a.contains("1")) {
            b = "1";
        } else if (a.contains("2")) {
            b = "2";
        } else if (a.contains("3")) {
            b = "3";
        } else if (a.contains(" 4 ")) {
            b = "4";
        } else {
            b = "";
        }
    } else if ("0".equals(b)) {
        if (a.contains("1")) {
            b = "1";
        } else if (a.contains("2")) {
            b = "2";
        } else if (a.contains("3")) {
            b = "3";
        } else if (a.contains("4")) {
            b = "4";
        } else {
            b = "";
        }
    } else if ("1".equals(b)) {
        if (a.contains("2")) {
            b = "2";
        } else if (a.contains("3")) {
            b = "3";
        } else if (a.contains("4")) {
            b = "4";
        } else {
            b = "";
        }
    }
    return b;
}

可以看到如果全部是顺序逻辑编写的话，会嵌套很多层的if-else，不利于后期维护时增加其他逻辑或者修改逻辑等，这时候就可以考虑使用策略模式来优化多层if-else的判断。

策略模式优化步骤

构造策略接口

通过上面的要求，可以了解到最外层是3次判断b的值，所以我们可以简单分类为3种策略，首先抽象出这3种策略的通用接口接口，然后再分3中实现方式实现这个接口

/**
 * 获取字符串策略接口
 */
public interface GetStringStrategy {
    String getStringStrategy(String a);
}

实现策略接口

编写策略接口的实现类，这里就是内层的判断，把内层的判断逻辑摘出来，改为3个策略接口的实现类

import demo.GetStringStrategy;

/**
 * b为空的实现类
 * @author dhbxs
 * @since 2025/9/12 9:19
 */
public class GetStringStrategyAImpl implements GetStringStrategy {

    @Override
    public String getStringStrategy(String a) {
        for (char ch : "01234".toCharArray()) {
            if (a.contains(String.valueOf(ch))) {
                return String.valueOf(ch);
            }
        }
        return "";
    }
}

import demo.GetStringStrategy;

/**
 * b为0的实现类
 * @author dhbxs
 * @since 2025/9/12 9:22
 */
public class GetStringStrategyBImpl implements GetStringStrategy {
    @Override
    public String getStringStrategy(String a) {
        for (char ch : "1234".toCharArray()) {
            if (a.contains(String.valueOf(ch))) {
                return String.valueOf(ch);
            }
        }
        return "";
    }
}

import demo.GetStringStrategy;

/**
 * b为1的实现类
 * @author dhbxs
 * @since 2025/9/12 9:22
 */
public class GetStringStrategyCImpl implements GetStringStrategy {
    @Override
    public String getStringStrategy(String a) {
        for (char ch : "234".toCharArray()) {
            if (a.contains(String.valueOf(ch))) {
                return String.valueOf(ch);
            }
        }
        return "";
    }
}

工厂类创建策略

有了策略接口，也有了3种策略对应的实现类，现在需要由统一的一个工厂类帮助我们创建这3种实现类的实体对象，隐藏具体调用的实现类，对外只暴露该工厂类，方便调用

package demo;

import demo.impl.GetStringStrategyAImpl;
import demo.impl.GetStringStrategyBImpl;
import demo.impl.GetStringStrategyCImpl;

import java.util.HashMap;
import java.util.Map;

/**
 * 创建策略工厂类
 *
 * @author dhbxs
 * @since 2025/9/12 9:24
 */
public class GetStringStrategyFactory {

    // 策略Map, Key 为策略类型, Value 为 策略具体实现类的接口 GetStringStrategy
    private static final Map<String, GetStringStrategy> strategis = new HashMap<>();

    // 提前创建好策略类，缓存到 Map 中
    static {
        strategis.put("", new GetStringStrategyAImpl());
        strategis.put("0", new GetStringStrategyBImpl());
        strategis.put("1", new GetStringStrategyCImpl());
    }

    /**
     * 传入判断条件，获取业务中需要使用的具体策略实现类
     *
     * @param condition 判断条件
     * @return 策略实现类
     */
    public static GetStringStrategy getStringStrategy(String condition) {
        if (condition == null) {
            throw new IllegalArgumentException("condition shoud not be null");
        }

        return strategis.get(condition);
    }
}

调用策略

有了工厂类后，调用方就不需要关心具体调用哪个实现类，只需要调用工厂方法就行，从而达到优化解耦合多重复杂 if-else 嵌套的判断逻辑

/**
 * 类似这种根据某一个值类型的不同，去执行不同的代码逻辑时，可以使用策略模式来优化
 *
 * @param a 内层条件a
 * @param b 外层条件b
 * @return b的值
 */
public static String getStringByStrategy(String a, String b) {
    GetStringStrategy stringStrategy = GetStringStrategyFactory.getStringStrategy(b);
    if (stringStrategy != null) {
        return stringStrategy.getStringStrategy(a);
    }
    return b;
}

public static void main(String[] args) {
    String a = "4";
    String b = "2";
    System.out.println(getStringByStrategy(a, b));
}