深入了解Java设计模式之策略模式

定义

定义了算法家族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户。

解决的问题

在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

核心要点

把变化的代码从不变的代码中分离出来

针对接口编程而不是具体实现（类）

多用组合/聚合，少用继承

客户端通过组合的方式使用策略

类图

溢出效用

对父类的局部改动，会影响其他部分（子类）、会有溢出效应

策略模式避免使用多重条件语句，比如if-else语句、Swtich语句

缺点：客户端必须知道所有的策略类，并且自行决定使用哪一个策略类。

代码实现

核心接口

/**
* 策略接口
*
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/9/6 - 18:13
*/
public interface Strategy {

//顶层策略接口
   void Strategy();

}

实现类-三个

/**
* 策略实现A
*
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/9/6 - 18:14
*/
public class ConcreteStrategyA  implements Strategy{

@Override
   public void Strategy() {
       System.out.println("算法A实现");
   }
}

/**
* 策略实现B
*
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/9/6 - 18:14
*/
public class ConcreteStrategyB implements Strategy {
   @Override
   public void Strategy() {
       System.out.println("算法B实现");
   }
}

/**
* 策略实现C
*
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/9/6 - 18:14
*/
public class ConcreteStrategyC implements Strategy{

@Override
   public void Strategy() {
       System.out.println("算法C实现");
   }
}

Context类

/**
* 策略配置类，维护一个Strategy的引用
*
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/9/6 - 18:15
*/
public class Context {

//声明策略接口
   private Strategy strategy;

//使用聚合的方式
   public Context(Strategy strategy) {
       this.strategy = strategy;
   }

//提供set方法，支持运行时改变算法
   public void setStrategy(Strategy strategy) {
       this.strategy = strategy;
   }

//根据具体的策略对象，调用其算法的方法
   public void ContextStrategy(){
       strategy.Strategy();
   }

}

Main方法

/**
* 策略模式启动类
*
* @author Promsing(张有博)
* @version 1.0.0
* @since 2022/9/6 - 18:19
*/
public class Main
{
   //TODO:代码可以优化，new的具体算法，可以放到配置文件中。
   //运行时读取配置文件
   public static void main(String[] args) {
       Context context;
       //new 一个context对象
       context=new Context(new ConcreteStrategyA());
       context.ContextStrategy();

//运行时改变策略
       context.setStrategy(new ConcreteStrategyB());
       context.ContextStrategy();

context.setStrategy(new ConcreteStrategyC());
       context.ContextStrategy();
   }

}

拓展

JDK源码

Comparator接口是一个常用的比较器，其中compare()就是一个策略模式的抽象体现

public static void main2(String[] args) {
       Integer[] ints={1,3,8,2,4,9,0};

Comparator<Integer> comparator = new Comparator<Integer>() {
           @Override
           public int compare(Integer o1, Integer o2) {
               if (o1 > o2) {
                   return 1;
               }
               return -1;
           }
       };

Arrays.sort(ints,comparator);

System.out.println(Arrays.toString(ints));

}

Spring源码

Spring的初始化采用了策略模式，即不同类型的类采用不同的初始化策略。

策略模式的注意实现和细节

1）策略模式的关键是 ：分析项目中变化部分与不变部分

2）策略模式的核心思想是 ：多用组合/聚合，少用继承；用行为类组合，而不是行为的继承。更有弹性。

3）体现了&ldquo;开闭原则&rdquo;。客户端增加行为不用修改原有代码，只要添加一种策略（或者行为）即可，避免了使用多重转移语句（if&hellip;else if &hellip; else)；

4）提供了可以替换继承关心的办法 ：策略模式将算法封装在独立的Strategy类中使得你可以独立于其Context改变它，使它易于切换、易于理解、易于扩展。

5）需要注意的是 ：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大。

来源：https://blog.csdn.net/promsing/article/details/126737647