14设计模式-行为型模式-状态模式

概述

状态（State）模式：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

状态模式包含以下主要角色。

• 环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。
• 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
• 具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。

说人话：就是抽象出一个行为，这个行为的不同节点会触发不同的状态，这个状态后面又会有不同的动作
举例：在电商环境下的售后状态流转等

coding

package com.xusj.future.behavioral.state;

/**
 * 售后抽象状态
 *
 * @author xusj
 * 
CreateDate 2022/8/6 0:07
 */
public interface AfterSale {
    /**
     * 售后动作节点
     */
    void toAfterSale();

    /**
     * 当前节点结束后的下一个动作是什么
     */
    AfterSale next();


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

package com.xusj.future.behavioral.state;

/**
 * @author xusj
 * 
CreateDate 2022/8/6 0:10
 */
public class ApplyAfterSale implements AfterSale {
    @Override
    public void toAfterSale() {
        System.out.println("申请售后节点");
    }

    @Override
    public AfterSale next() {
        // 下一个节点等待商家同意节点
        return new waitSeller();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package com.xusj.future.behavioral.state;

/**
 * @author xusj
 * 
CreateDate 2022/8/6 0:11
 */
public class waitSeller implements AfterSale {
    @Override
    public void toAfterSale() {
        System.out.println("这个节点是等待卖家同意");
    }

    @Override
    public AfterSale next() {
        return new waitBuyer();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package com.xusj.future.behavioral.state;

/**
 * @author xusj
 * 
CreateDate 2022/8/6 0:12
 */
public class waitBuyer implements AfterSale {
    @Override
    public void toAfterSale() {
        System.out.println("这个节点等待买家上传凭证");
    }

    @Override
    public AfterSale next() {
        return null;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package com.xusj.future.behavioral.state;

/**
 * 售后环境类
 *
 * @author xusj
 * 
CreateDate 2022/8/6 0:13
 */
public class ContextAfterSale {
    // 组合
    private AfterSale afterSale;

    // 多态构造方法
    public ContextAfterSale(AfterSale afterSale) {
        this.afterSale = afterSale;
    }

    /**
     * 开始售后，到每一个节点
     */
    public void startAfterSale() {
        afterSale.toAfterSale();
    }

    /**
     * 流转到下一个节点,又将下一个状态付给当前属性
     */
    public void nextStatus() {
        afterSale = afterSale.next();
    }

}

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

package com.xusj.future.behavioral.state;

/**
 * @author xusj
 * 
CreateDate 2022/8/6 0:21
 */
public class Test {
    public static void main(String[] args) {
        // 1、申请,多态
        AfterSale afterSaleStatus = new ApplyAfterSale();

        ContextAfterSale contextAfterSale = new ContextAfterSale();
        contextAfterSale.setAfterSale(afterSaleStatus);
        contextAfterSale.startAfterSale();
        contextAfterSale.nextStatus();
        // 2、等买家同意
        afterSaleStatus.toAfterSale();
        afterSaleStatus.next();

        // .... 一步一步到后面的状态
        
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

总结

1、适用场景：行为模型，在一些行为的抽象时适用。不同的状态在做同一件事情有不同的结果，可能还会伴有一些状态的流转

下文引用处
模式优点
1）封装了转换规则。在状态模式中无需使用条件语句来进行判断。

2）枚举可能的状态，在枚举状态之前需要确定状态种类。

3）将所有与某个有关状态的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象地状态即可改变对象的行为。

4）允许状态转换逻辑和状态对象合成一体，而不是一个巨大的条件语句块。

5）可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

模式缺点
1）状态模式的使用会增加系统类和对象的数量。

2）代码实现和模式结构较为复杂。

3）对于新增加的状态类，需要修改那些负责状态转换的源码，违背了“开闭原则”。