两种语言实现设计模式（C++和Java）（十六：状态模式）

Posted 2022-06-28 asp1rant

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

状态模式是一种对象行为型模式，其主要优点如下。

1. 状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
2. 减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
3. 有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

状态模式的主要缺点如下。

1. 状态模式的使用必然会增加系统的类与对象的个数。
2. 状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。

UML：

示例：

以仓库里的无人仓储物流机器人（AGV）为例，设计AGV的工作模式时，为AGV定义3种状态：空闲状态（接收任务），工作状态（接收新任务后放入任务队列等待执行），故障状态（不接收任何任务），代码实现如下：

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 //命令类，传递到状态中执行
 6 class Order
 7 private:
 8     bool accepted;
 9 public:
10     string orderId;
11     Order(string _id)
12         orderId = _id;
13         accepted = false;
14     
15     void accept()
16         accepted = true;
17     
18 ;
19 
20 //状态抽象类
21 class State
22 protected:
23     string name;
24 public:
25     State(string _name)
26         name = _name;
27     
28     virtual void handleNewOrder(Order *order) = 0;
29     string getName()
30         return name;
31     
32 ;
33 
34 //具体状态类
35 class StateRunning:public State
36 public:
37     using State::State;
38     virtual void handleNewOrder(Order* order)
39         cout << name << "忙碌中,将任务添加到任务序列" << order->orderId << endl;
40         order->accept();
41     
42 ;
43 
44 class StateWaiting:public State
45 public:
46     using State::State;
47     virtual void handleNewOrder(Order* order)
48         cout << name <<"立即执行任务" << order->orderId << endl;
49         order->accept();
50     
51 ;
52 
53 class StateFault:public State
54 public:
55     using State::State;
56     virtual void handleNewOrder(Order* order)
57         cout << name <<"故障，不接收任务" << endl;
58     
59 ;
60 
61 //环境类，AGV
62 class Agv
63 private:
64     State *state;
65 public:
66     void receiveNewOrder(Order* order)
67         state->handleNewOrder(order);
68     
69 
70     void setState(State* state)
71         this->state = state;
72     
73 
74     string getState()
75         return state->getName();
76     
77 ;
78 
79 int main()
80 
81     Agv agv;
82     State *pStateRunning = new StateRunning("running");
83     State *pStateWaiting = new StateWaiting("waiting");
84     State *pStateFault = new StateFault("fault");
85     agv.setState(pStateRunning);
86     agv.receiveNewOrder(new Order("1"));
87     agv.setState(pStateWaiting);
88     agv.receiveNewOrder(new Order("2"));
89     agv.setState(pStateFault);
90     agv.receiveNewOrder(new Order("3"));
91     return 0;
92 

Java实现如下：

  1 public class Order 
  2 
  3     private String name;
  4 
  5     private boolean accepted;
  6 
  7     public Order(String name)
  8         this.name = name;
  9         accepted = false;
 10     
 11 
 12     public void accept()
 13         this.accepted = true;
 14     
 15 
 16     public String getName()
 17         return this.name;
 18     
 19 
 20 
 21 public abstract class State 
 22 
 23     protected String name;
 24 
 25     public State(String name)
 26         this.name = name;
 27     
 28 
 29     public String getName()
 30         return name;
 31     
 32 
 33     public void handleNewOrder(Order order)
 34 
 35 
 36 public class StateRunning extends State 
 37 
 38     public StateRunning(String name)
 39         super(name);
 40     
 41 
 42     @Override
 43     public void handleNewOrder(Order order) 
 44         System.out.println(name + "忙碌中,将任务添加到任务序列" + order.getName());
 45         order.accept();
 46     
 47 
 48 
 49 public class StateWaiting extends State 
 50 
 51     public StateWaiting(String name)
 52         super(name);
 53     
 54 
 55     @Override
 56     public void handleNewOrder(Order order) 
 57         System.out.println(name + "立即执行任务" + order.getName());
 58         order.accept();
 59     
 60 
 61 
 62 public class StateFault extends State 
 63 
 64     public StateFault(String name)
 65         super(name);
 66     
 67 
 68     @Override
 69     public void handleNewOrder(Order order) 
 70         System.out.println(name + "故障，不接收任务");
 71     
 72 
 73 
 74 public class Agv 
 75 
 76     private State state;
 77 
 78     public String getState() 
 79         return state.getName();
 80     
 81 
 82     public void setState(State state) 
 83         this.state = state;
 84     
 85 
 86     public void receiveNewOrder(Order order)
 87         state.handleNewOrder(order);
 88     
 89 
 90 
 91 public class Main 
 92     public static void main(String[] args) 
 93         Agv agv = new Agv();
 94         State stateRunning = new StateRunning("running");
 95         State stateWaiting = new StateWaiting("waiting");
 96         State stateFault = new StateFault("fault");
 97         agv.setState(stateRunning);
 98         agv.receiveNewOrder(new Order("1"));
 99         agv.setState(stateWaiting);
100         agv.receiveNewOrder(new Order("2"));
101         agv.setState(stateFault);
102         agv.receiveNewOrder(new Order("3"));
103     
104 

输出：

running忙碌中,将任务添加到任务序列1
waiting立即执行任务2
fault故障，不接收任务