状态模式-State-订单状态

JAVA设计模式-状态模式-State-订单状态

21. State（状态）

 

 

意图：

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

解释：

比如说对订单的提交，第一次提交是成功的，但是第二次提交的时候就会是失败的，因为其内部状态已经改变，而外部都是“订单”调用了“提交”方法，同一个行为，但是实质上造成的效果已经不同。

 

适用性：

一个对象的行为取决于它的状态, 并且它必须在运行时刻根据状态改变它的行为。

一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常, 有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。

解释：

行为取决于它的状态，即是说由状态决定行为，方法放在状态类中，而状态控制亦在状态类中进行，譬如一个按钮，按一次是开，按一次是关，同一个行为，但是由于其状态的改变，而导致不同的结果。

一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常, 有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得你可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象而独立变化。

即是说以前你需要在某个行为的方法里面用if/else或者switch中写的一堆业务，现在可以转移到状态类中了，而该状态类是独立的，非常便于流程管理。譬如之前的开关，你需要在toggle()中写if/else，并且需要返回flag以便判断状态，而使用状态类，将状态分为开/关两种状态，只需要在状态类的toggle()方法中写入逻辑，将行为后的状态返回即可。

 

实现：

需要实现这个逻辑：

那么我们就需要

3个具体状态类（已预订，已确认，已锁定）

以及3个行为（确认，修改，支付）

 

抽象状态类

1. abstract class OrderState {
2. abstract void confirm(OrderContext orderContext);
3. abstract void modify(OrderContext orderContext);
4. abstract void pay(OrderContext orderContext);
5. }

具体状态类

1. class OrderedState extends OrderState {
2. @Override
3. void confirm(OrderContext orderContext) {
4. System.out.println("订单已确认");
5. orderContext.setState(new ConfirmedState());
6. }
7. @Override
8. void modify(OrderContext orderContext) {
9. System.out.println("订单已修改");
10. orderContext.setState(this);
11. }
12. @Override
13. void pay(OrderContext orderContext) {
14. System.out.println("预定状态无法完成订单！");
15. }
16. }
17. class ConfirmedState extends OrderState {
18. @Override
19. void confirm(OrderContext orderContext) {
20. System.out.println("订单已确认，请勿重复确认");
21. }
22. @Override
23. void modify(OrderContext orderContext) {
24. System.out.println("订单已修改，请再次确认");
25. orderContext.setState(new OrderedState());
26. }
27. @Override
28. void pay(OrderContext orderContext) {
29. System.out.println("订单已支付，无法再修改");
30. orderContext.setState(new LockedState());
31. }
32. }
33. class LockedState extends OrderState {
34. @Override
35. void confirm(OrderContext orderContext) {
36. System.out.println("订单已锁定");
37. }
38. @Override
39. void modify(OrderContext orderContext) {
40. System.out.println("订单已锁定");
41. }
42. @Override
43. void pay(OrderContext orderContext) {
44. System.out.println("订单已锁定");
45. }
46. }

背景类

1. class OrderContext {
2. OrderState state = null;
3. //新建订单设为已预定状态
4. OrderContext() {
5. this.state = new OrderedState();
6. }
7. void setState(OrderState state) {
8. this.state = state;
9. }
10. public void confirm() {
11. state.confirm(this);
12. }
13. public void modify() {
14. state.modify(this);
15. }
16. public void pay() {
17. state.pay(this);
18. }
19. }

测试：

1. public static void main(String[] args) {
2. OrderContext orderContext = new OrderContext();
3. orderContext.confirm();     //已预定状态>已确认状态
4. orderContext.modify();      //已确认状态>已预定状态
5. orderContext.confirm();    //已预定状态>已确认状态
6. orderContext.pay();       //已确认状态>已锁定状态
7. orderContext.modify();    //已锁定状态
8. }

1. 订单已确认
2. 订单已修改，请再次确认
3. 订单已确认
4. 订单已支付，无法再修改
5. 订单已锁定