设计模式（十九）之行为型模式--策略模式

发表于 | 阅读次数:
字数统计: 1.9k | 阅读时长 ≈ 8

一、策略模式

1、案例

1.1 鸭子问题

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

  1. 有各种鸭子（比如野鸭、北京鸭、水鸭等，鸭子有各种行为，比如叫、飞行等）
  2. 显示鸭子的信息

1.2 传统方案

image-20210815214256038

image-20210815214454539

1.3 传统方案代码实例

1.3.1 Duck抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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(" 鸭子会飞~ ");
    }
}

1.3.2 WildDuck类

野鸭，继承Duck

1
2
3
4
5
6
public class WildDuck extends Duck{
    @Override
    public void display() {
        System.out.println(" 这是野鸭~ ");
    }
}

1.3.3 PekingDUck类

北京鸭，继承Duck

1
2
3
4
5
6
7
8
9
10
11
12
13
public class PekingDUck extends Duck{
    @Override
    public void display() {
        System.out.println(" 这是北京鸭~ ");
    }

    // 因为北京鸭不能飞翔，因此需要重写fly

    @Override
    public void fly() {
        System.out.println(" 北京鸭不能飞翔~ ");
    }
}

1.3.4 ToyDuck类

玩具鸭，继承Duck

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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(" 玩具鸭不会飞~ ");
    }
}

1.4 传统方案问题分析

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

2、策略模式基本介绍

2.1 基本介绍

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

2.2 原理类图

image-20210815221004503

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

3、代码实例

3.1 代码类图

image-20210815221928829

3.2 代码

3.2.1 FlyBehavior接口

1
2
3
public interface FlyBehavior {
    void fly();//子类具体实现
}

3.2.2 GoodFlyBehavior类

1
2
3
4
5
6
public class GoodFlyBehavior implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println(" 飞翔技术高超~ ");
    }
}

3.2.3 BadFlyBehavior类

1
2
3
4
5
6
public class BadFlyBehavior implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println(" 飞翔技术一般~ ");
    }
}

3.2.4 NoFlyBehavior类

1
2
3
4
5
6
public class NoFlyBehavior implements FlyBehavior{
    @Override
    public void fly() {
        System.out.println(" 不会飞翔 ");
    }
}

3.2.5 Duck抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public abstract class Duck {

    //属性，策略接口
    FlyBehavior flyBehavior;

    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();
        }
    }
}

3.2.6 WildDuck类

1
2
3
4
5
6
7
8
9
10
public class WildDuck extends Duck {
    public WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }

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

3.2.7 PekingDUck类

1
2
3
4
5
6
7
8
9
10
11
public class PekingDUck extends Duck {

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

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

3.2.8 ToyDuck类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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(" 玩具鸭不会游泳~");
    }
}

3.2.9 Client类

1
2
3
4
5
6
7
8
9
10
11
12
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();
    }
}

结果：

1
2
3
飞翔技术高超~ 
不会飞翔 
不会飞翔

3.2.10 改进

假如 ，想要让北京鸭飞起来，但是非的不好，可以修改Duck抽象类，添加set方法

3.2.10.1 Duck抽象类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public abstract class Duck {

    //属性，策略接口
    FlyBehavior flyBehavior;

    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;
    }
}
3.2.10.2 Client类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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 BadFlyBehavior());
        System.out.println(" 北京鸭的实际飞翔能力 ");
        pekingDUck.fly();
    }
}

结果：

1
2
3
4
5
飞翔技术高超~ 
不会飞翔 
不会飞翔 
北京鸭的实际飞翔能力 
飞翔技术一般~

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

4.1 代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if(o1 > o2){
                    return 1;
                }else{
                    return -1;
                }
            };
        };
        
        Arrays.sort(data,comparator);
        /*
        public static <T> void sort(T[] a, Comparator<? super T> c) {
            if (c == null) {
                sort(a);
            } else {
                if (LegacyMergeSort.userRequested)
                    legacyMergeSort(a, c);
                else
                    TimSort.sort(a, 0, a.length, c, null, 0, 0);
                }
            }
        * */
        System.out.println(Arrays.toString(data));
        
        //方式二 lambada表示是
        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));
    }
}

结果：

1
2
[1, 2, 3, 4, 8, 9]
data2=[11, 12, 13, 14, 18, 19]

若要实现降序排列，只需要将下列中的1和-1进行调换即可

image-20210815224312089

4.2 分析

(1)ctrl +B 发现，Comparator是以恶搞接口

1
public interface Comparator<T> {}

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

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