一、定义、类型及类图

  • 定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换。(策略模式定义了算法家族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化,不会影响到使用算法的客户——出自《大话设计模式》)
  • 类型:行为类模式
  • 类图

行为类模式--策略模式

    策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,相互之间可以替换。在前面说过的行为类模式中,有一种模式也是关注对算法的封装——模版方法模式,对照类图可以看到,策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context,它与模版方法模式的区别在于:在模版方法模式中,调用算法的主体在抽象的父类中,而在策略模式中,调用算法的主体则是封装到了封装类Context中,抽象策略Strategy一般是一个接口,目的只是为了定义规范,里面一般不包含逻辑。其实,这只是通用实现,而在实际编程中,因为各个具体策略实现类之间难免存在一些相同的逻辑,为了避免重复的代码,我们常常使用抽象类来担任Strategy的角色,在里面封装公共的代码,因此,在很多应用的场景中,在策略模式中一般会看到模版方法模式的影子。

二、策略模式的结构

  • 环境(Context)角色:持有一个Strategy的引用,也叫上下文,对策略进行二次封装,目的是避免高层模块对策略的直接调用。
  • 抽象策略(Strategy):通常情况下为一个接口,当各个实现类中存在着重复的逻辑时,则使用抽象类来封装这部分公共的代码,此时,策略模式看上去更像是模版方法模式。
  • 具体策略(ConcreteStrategy):具体策略角色通常由一组封装了算法的类来担任,这些类之间可以根据需要*替换。

三、策略模式代码实现

interface IStrategy {
    public void doSomething();
}
class ConcreteStrategy1 implements IStrategy {
    public void doSomething() {
        System.out.println("具体策略1");
    }
}
class ConcreteStrategy2 implements IStrategy {
    public void doSomething() {
        System.out.println("具体策略2");
    }
}
class Context {
    private IStrategy strategy;
    
    public Context(IStrategy strategy){
        this.strategy = strategy;
    }
    
    public void execute(){
        strategy.doSomething();
    }
}
 
public class Client {
    public static void main(String[] args){
        Context context;
        System.out.println("-----执行策略1-----");
        context = new Context(new ConcreteStrategy1());
        context.execute();
 
        System.out.println("-----执行策略2-----");
        context = new Context(new ConcreteStrategy2());
        context.execute();
    }
}

四、策略模式的优缺点

  • 主要优点:
    1. 策略类之间可以*切换,由于策略类实现自同一个抽象,所以他们之间可以*切换。
    2. 易于扩展,增加一个新的策略对策略模式来说非常容易,基本上可以在不改变原有代码的基础上进行扩展。
    3. 避免使用多重条件,如果不使用策略模式,对于所有的算法,必须使用条件语句进行连接,通过条件判断来决定使用哪一种算法,在上一篇文章中我们已经提到,使用多重条件判断是非常不容易维护的。
  • 主要缺点:
    1. 维护各个策略类会给开发带来额外开销,可能大家在这方面都有经验:一般来说,策略类的数量超过5个,就比较令人头疼了。
    2. 必须对客户端(调用者)暴露所有的策略类,因为使用哪种策略是由客户端来决定的,因此,客户端应该知道有什么策略,并且了解各种策略之间的区别,否则,后果很严重。例如,有一个排序算法的策略模式,提供了快速排序、冒泡排序、选择排序这三种算法,客户端在使用这些算法之前,是不是先要明白这三种算法的适用情况?再比如,客户端要使用一个容器,有链表实现的,也有数组实现的,客户端是不是也要明白链表和数组有什么区别?就这一点来说是有悖于迪米特法则的。
  • 优点补充(出自——大话设计模式):
    1. 策略模式是一种定义一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,它可以以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合。
    2. 策略模式的Strategy实现层为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。
    3. 简化了单元测试,因为每个算法都有自己的类,可以通过自己的接口单独测试。
    4. 当不同的行为堆砌在一个类中时,就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的ConcreteStrategy类中,可以在使用这些行为的类中消除条件语句
    5. 策略模式就是用来封装算法的,但在实践中,我们发现可以用它来封装几乎任何类型的规则,只要在分析过程中听到需要在不同时间应用不用的业务规则,就可以考虑使用策略模式处理这种变化的可能性。

五、适用常见

     做面向对象设计的,对策略模式一定很熟悉,因为它实质上就是面向对象中的继承和多态,在看完策略模式的通用代码后,我想,即使之前从来没有听说过策略模式,在开发过程中也一定使用过它吧?至少在在以下两种情况下,大家可以考虑使用策略模式,

  • 几个类的主要逻辑相同,只在部分逻辑的算法和行为上稍有区别的情况。
  • 有几种相似的行为,或者说算法,客户端需要动态地决定使用哪一种,那么可以使用策略模式,将这些算法封装起来供客户端调用。

       策略模式是一种简单常用的模式,我们在进行开发的时候,会经常有意无意地使用它,一般来说,策略模式不会单独使用,跟模版方法模式、工厂模式等混合使用的情况比较多。

 

六、JDK的策略模式应用

1、ThreadPoolExecutor(线程池)中的RejectedExecutionHandler

学习ThreadPoolExecutor(线程池)就肯定要知道它的构造方法每个参数的意义:

    /**
     * Handler called when saturated or shutdown in execute.
     */
    private volatile RejectedExecutionHandler handler;    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {        //....
        this.handler = handler;
    }    /**
     * Invokes the rejected execution handler for the given command.
     * Package-protected for use by ScheduledThreadPoolExecutor.
     */
    final void reject(Runnable command) {
        handler.rejectedExecution(command, this);
    }

 

其中我们可以找到RejectedExecutionHandler,这个参数代表的是拒绝策略(有四种具体的实现:直接抛出异常、使用调用者的线程来处理、直接丢掉这个任务、丢掉最老的任务)

行为类模式--策略模式

其实这就是策略模式的体现了。

2 Java 对象排序中的应用

Comparator 外部比较器接口 我们如果需要控制某个类的次序,而该类本身不支持排序(即没有实现Comparable接口);那么可以建立一个该类的比较器来排序,这个比较器只需要实现Comparator接口即可。,通过实现Comparator类来新建一个比较器,然后通过该比较器来对类进行排序。Comparator 接口其实就是一种策略模式的实践 事例代码: 抽象策略类 Comparator

public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
 }

 

具体策略类 SortComparator

public class SortComparator implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        Student student1 = (Student) o1;
        Student student2 = (Student) o2;
        return student1.getAge() - student2.getAge();
    }
}

 

策略模式上下文 Collections

public class Client {

    public static void main(String[] args) {

        Student stu[] = {
                new Student("张三" ,23),
                new Student("李四" ,26)
                , new Student("王五" ,22)};
        Arrays. sort(stu,new SortComparator());
        System.out.println(Arrays.toString(stu));

        List<Student> list = new ArrayList<>(3);
        list.add( new Student("zhangsan" ,31));
        list.add( new Student("lisi" ,30));
        list.add( new Student("wangwu" ,35));
        Collections. sort(list,new SortComparator());
        System.out.println(list);

    }

}

 

数据流

countRunAndMakeAscending:355, TimSort (java.util)
sort:220, TimSort (java.util)
sort:1438, Arrays (java.util)
main:20, Client (designpattern.strategy.compare)

 

调用Collections.sort方法之后走的是Arrays.sort()方法,然后TimSort类中countRunAndMakeAscending方法中调用具体比较器的算法实现进行比较,完成排序。这是大家比较常用的对象排序工具类。

 

 

分类:

技术点:

相关文章: