【设计模式】策略模式

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

基本介绍

意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。
主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。
何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。
如何解决：将这些算法封装成一个一个的类，任意地替换。
关键代码：实现同一个接口。
应用实例：
- 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。
- 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。
- 3、JAVA AWT 中的 LayoutManager。
优点：
- 1、算法可以自由切换。
- 2、避免使用多重条件判断。
- 3、扩展性良好。
缺点：
- 1、策略类会增多。
- 2、所有策略类都需要对外暴露。
使用场景：
- 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
- 2、一个系统需要动态地在几种算法中选择一种。
- 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

概括

基本介绍

策略模式（Strategy Pattern）中，定义算法族（策略组），分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
这算法体现了几个设计原则，第一、把变化的代码从不变的代码中分离出来；第二、针对接口编程而不是具体类（定义了策略接口）；第三、多用组合/聚合，少用继承（客户通过组合方式使用策略）。

策略模式的原理类图

角色分析：

Context：上下文环境类，根据传入的策略变换某一方法行为。
Strategy：策略类，保存不同的方法策略，将某一方法策略与此对象一一对应。

说明：从上图可以看到，客户 context 有成员变量 strategy 或者其他的策略接口，至于需要使用到哪个策略，我们可以在构造器中指定

我的理解

一个人去北京可以有很多策略去，比如说坐车、坐船、坐火车、坐高铁、坐飞机，这些都是同一个类的不同策略，可以不断更改变化，比如坐车到其他地方转火车。

跟不同类型的 MM 约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，单目的都是为了得到 MM 的芳心，我的追 MM 锦囊中有好多 Strategy 哦。

策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

应用实例

编写鸭子项目，具体要求如下:

有各种鸭子(比如野鸭、北京鸭、水鸭等，鸭子有各种行为，比如叫、飞行等)
显示鸭子的信息

使用传统方式

传统的设计方案(类图)

代码实现

Duck

package com.nemo.strategy;

public abstract class Duck {

    public Duck() {}

    public abstract void display();//显示鸭子信息

    public void quack() {
        System.out.println("鸭子嘎嘎叫~~");
    }

    public void swim() {
        System.out.println("鸭子会游泳~~");
    }

    public void fly() {
        System.out.println("鸭子会飞翔~~~");
    }
}

PekingDuck

package com.nemo.strategy;

public class PekingDuck extends Duck {

    @Override
    public void display() {
        System.out.println("~~北京鸭~~~");
    }

    //因为北京鸭不能飞翔，因此需要重写 fly @Override
    public void fly() {
    System.out.println("北京鸭不能飞翔");
    }
}

ToyDuck

package com.nemo.strategy;

public class ToyDuck extends Duck{

    @Override
    public void display() {
        System.out.println("玩具鸭");
    }

    //需要重写父类的所有方法 
    public void quack() {
        System.out.println("玩具鸭不能叫~~");
    }

    public void swim() {
        System.out.println("玩具鸭不会游泳~~");
    }

    public void fly() {
        System.out.println("玩具鸭不会飞翔~~~");
    }
}

WildDuck

package com.nemo.strategy;

public class WildDuck extends Duck {

    @Override
    public void display() {
        System.out.println(" 这是野鸭 ");
    }
}

Client

package com.nemo.strategy;

public class Client {

    public static void main(String[] args) {
        //测试
    }
}

传统的方式实现的问题分析和解决方案

其它鸭子，都继承了 Duck 类，所以 fly 让所有子类都会飞了，这是不正确的
上面说的 1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改动，会影响其他部分。会有溢出效应
为了改进 1 问题，我们可以通过覆盖 fly 方法来解决 => 覆盖解决
问题又来了，如果我们有一个玩具鸭子 ToyDuck, 这样就需要 ToyDuck 去覆盖 Duck 的所有实现的方法 => 解决思路 -》策略模式

使用策略模式

应用实例要求
编写程序完成前面的鸭子项目，要求使用策略模式
思路分析(类图)
策略模式：分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体设定行为对象。原则就是：分离变化部分，封装接口，基于接口编程各种功能。此模式让行为的变化独立于算法的使用者

代码实现

Duck

package com.nemo.strategy.improve;

public abstract class Duck {

    //属性, 策略接口
    FlyBehavior flyBehavior;
    //其它属性<->策略接口
    QuackBehavior quackBehavior;


    public Duck() {}

    public abstract void display();//显示鸭子信息

    public void quack() {
    System.out.println("鸭子嘎嘎叫~~");
    }


    public void swim() {
        System.out.println("鸭子会游泳~~");
    }

    public void fly() {
        //改进
        if(flyBehavior != null) { 
            flyBehavior.fly();
        }
    }

    public void setFlyBehavior(FlyBehavior flyBehavior) { 
        this.flyBehavior = flyBehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) { 
        this.quackBehavior = quackBehavior;
    }
}

ToyDuck

package com.nemo.strategy.improve;

public class ToyDuck extends Duck{

    public ToyDuck() {
        flyBehavior = new NoFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println("玩具鸭");
    }

    //需要重写父类的所有方法 
    public void quack() {
        System.out.println("玩具鸭不能叫~~");
    }

    public void swim() {
        System.out.println("玩具鸭不会游泳~~");
    }
}

WildDuck

package com.nemo.strategy.improve;

public class WildDuck extends Duck {

    //构造器，传入 FlyBehavor 的对象
    public  WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println(" 这是野鸭 ");
    }
}

PekingDuck

package com.nemo.strategy.improve;

public class PekingDuck extends Duck {

    //假如北京鸭可以飞翔，但是飞翔技术一般 
    public PekingDuck() {
        flyBehavior = new BadFlyBehavior();
    }

    @Override
    public void display() {
        System.out.println("~~北京鸭~~~");
    }
}

FlyBehavior

package com.nemo.strategy.improve;

public interface FlyBehavior {

    void fly(); //  子类具体实现
}

NoFlyBehavior

package com.nemo.strategy.improve;

public class NoFlyBehavior implements FlyBehavior{

    @Override
    public void fly() {
        System.out.println(" 不会飞翔   ");
    }
}

BadFlyBehavior

package com.nemo.strategy.improve;

public class BadFlyBehavior implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println(" 飞翔技术一般 ");
    }
}

GoodFlyBehavior

package com.nemo.strategy.improve;

public class GoodFlyBehavior implements FlyBehavior {

    @Override
    public void fly() {
        System.out.println(" 飞翔技术高超 ~~~");
    }
}

QuackBehavior

package com.nemo.strategy.improve;

public interface QuackBehavior { 
    void quack();//子类实现
}

Client

package com.nemo.strategy.improve;

public class Client {

    public static void main(String[] args) {
        WildDuck wildDuck = new WildDuck(); 
        wildDuck.fly();

        ToyDuck toyDuck = new ToyDuck(); 
        toyDuck.fly();

        PekingDuck pekingDuck = new PekingDuck(); 
        pekingDuck.fly();

        //动态改变某个对象的行为, 北京鸭 不能飞
        pekingDuck.setFlyBehavior(new NoFlyBehavior());
        System.out.println("北京鸭的实际飞翔能力");
        pekingDuck.fly();
    }
}

优化改进

诶，大家是不是觉得这策略模式把问题变得更麻烦了，本来几个方法就可以解决的问题，偏要抽出来提取成一个类，一点也不简单啊！每次要使用新的功能，都必须创建一个新的类，跟原来创建一个方法不是没两样吗？？？

那么，下面我们来优化改进一下，其实也不能说优化改进，之前换了个用法而已。。我们来使用匿名内部类或者lambda表达式来优化试试。

我们可以不创建新的类，直接使用匿名内部类和lambda表达式来在pekingDuck.setFlyBehavior(new NoFlyBehavior());方法参数对象中直接new一个接口实现它的抽象方法，不是方便多了吗，不用创建新的类了！

策略模式在 JDK-Arrays 应用的源码分析

JDK 的 Arrays 的 Comparator 就使用了策略模式
代码分析+Debug 源码+模式角色分析

代码演示：

package com.nemo.jdk;

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

public class Strategy {

    public static void main(String[] args) {
        //数组
        Integer[] data = { 9, 1, 2, 8, 4, 3 };
        // 实现降序排序，返回-1 放左边，1 放右边，0 保持不变
        // 说 明
        // 1.  实现了 Comparator 接口（策略接口） , 匿名类 对象 new Comparator<Integer>(){..}
        // 2.  对象 new Comparator<Integer>(){..}  就是实现了 策略接口 的对象
        // 3. public int compare(Integer o1, Integer o2){} 指定具体的处理方式
        Comparator<Integer> comparator = new Comparator<Integer>() { 
            public int compare(Integer o1, Integer o2) {
                if (o1 > o2) {
                    return -1;
                } else {
                    return 1;
                }
            };
        };

        // 说 明
       /**
        * public static <T> void sort(T[] a, Comparator<? super T> c) { 
        *     if (c == null) {
        *         sort(a); //默认方法
        *     } else {
        *         if (LegacyMergeSort.userRequested) 
        *             legacyMergeSort(a, c); //使用策略对象 c
        *     else
        *         // 使用策略对象 c
        *         TimSort.sort(a, 0, a.length, c, null, 0, 0);
        *     }
        * }
        */
       
        //方式 1
        Arrays.sort(data, comparator); 
        System.out.println(Arrays.toString(data)); // 降序排序

        //方式 2- 同时 lambda 表达式实现 策略模式
        Integer[] data2 = { 19, 11, 12, 18, 14, 13 };

        Arrays.sort(data2, (var1, var2) -> { 
            if(var1.compareTo(var2) > 0) {
                return -1;
            } else {
                return 1;
            }
        });
        System.out.println("data2=" + Arrays.toString(data2));
    }
}

策略模式的注意事项和细节

策略模式的关键是：分析项目中变化部分与不变部分
策略模式的核心思想是：多用组合/聚合少用继承；用行为类组合，而不是行为的继承。更有弹性
体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为）即可，避免了使用多重转移语句（if..else if..else）
提供了可以替换继承关系的办法：策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其 Context 改变它，使它易于切换、易于理解、易于扩展
需要注意的是：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞大

posted @ 2020-07-09 17:38 Nemo& 阅读(311) 评论(0) 编辑收藏举报

刷新页面返回顶部

𝓝𝓮𝓶𝓸

没有人在意你说什么，人们只听得见他们想听的....

Nemo&

【设计模式】策略模式

基本介绍

概括

我的理解

应用实例

使用传统方式

Duck

PekingDuck

ToyDuck

WildDuck

Client

使用策略模式

Duck

ToyDuck

WildDuck

PekingDuck

FlyBehavior

NoFlyBehavior

BadFlyBehavior

GoodFlyBehavior

QuackBehavior

Client

优化改进

策略模式在 JDK-Arrays 应用的源码分析

策略模式的注意事项和细节

公告