unity设计模式-状态模式

状态模式

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。

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

介绍

意图：允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。

主要解决：对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

何时使用：代码中包含大量与对象状态有关的条件语句。

如何解决：将各种具体的状态类抽象出来。

关键代码：通常命令模式的接口中只有一个方法。而状态模式的接口中有一个或者多个方法。而且，状态模式的实现类的方法，一般返回值，或者是改变实例变量的值。也就是说，状态模式一般和对象的状态有关。实现类的方法有不同的功能，覆盖接口中的方法。状态模式和命令模式一样，也可以用于消除 if...else 等条件选择语句。

优点：

 1、封装了转换规则。

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

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

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

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

缺点：

 1、状态模式的使用必然会增加系统类和对象的个数。

 2、状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。

 3、状态模式对"开闭原则"的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源代码，否则无法切换到新增状态，而且修改某个状态类的行为也需修改对应类的源代码。

使用场景： 1、行为随状态改变而改变的场景。 2、条件、分支语句的代替者。

注意事项：在行为受状态约束的时候使用状态模式，而且状态不超过 5 个。

结构图：

应用实例： 

[csharp]  view plain  copy

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class TestState : MonoBehaviour {  
5.   
6.     // Use this for initialization  
7.     void Start () {  
8.         // 设置Context的初始状态为ConcreteStateA  
9.         Context context = new Context(new ConcreteStateA());  
10.   
11.         // 不断地进行请求，同时更改状态  
12.         context.Request();  
13.         context.Request();  
14.         context.Request();  
15.         context.Request();  
16.     }  
17. }  
18.   
19. /// <summary>  
20. /// Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态。  
21. /// </summary>  
22. public class Context  
23. {  
24.     private State state;  
25.     /// <summary>  
26.     /// 定义Context的初始状态  
27.     /// </summary>  
28.     /// <param name="state"></param>  
29.     public Context(State state)  
30.     {  
31.         this.state = state;  
32.     }  
33.   
34.     /// <summary>  
35.     /// 可读写的状态属性，用于读取和设置新状态  
36.     /// </summary>  
37.     public State State  
38.     {  
39.         get { return state; }  
40.         set { state = value; }  
41.     }  
42.   
43.     /// <summary>  
44.     /// 对请求做处理，并设置下一个状态  
45.     /// </summary>  
46.     public void Request()  
47.     {  
48.         state.Handle(this);  
49.     }  
50. }  
51.   
52. /// <summary>  
53. /// 抽象状态类，定义一个接口以封装与Context的一个特定状态相关的行为  
54. /// </summary>  
55. public abstract class State  
56. {  
57.     public abstract void Handle(Context context);  
58. }  
59.   
60. /// <summary>  
61. /// 具体状态类，每一个子类实现一个与Context的一个状态相关的行为  
62. /// </summary>  
63. public class ConcreteStateA : State  
64. {  
65.     /// <summary>  
66.     /// 设置ConcreteStateA的下一个状态是ConcreteStateB  
67.     /// </summary>  
68.     /// <param name="context"></param>  
69.     public override void Handle(Context context)  
70.     {  
71.         Debug.Log("当前状态是 A.");  
72.         context.State = new ConcreteStateB();  
73.     }  
74. }  
75.   
76. public class ConcreteStateB : State  
77. {  
78.     /// <summary>  
79.     /// 设置ConcreteStateB的下一个状态是ConcreteSateA  
80.     /// </summary>  
81.     /// <param name="context"></param>  
82.     public override void Handle(Context context)  
83.     {  
84.         Debug.Log("当前状态是 B.");  
85.         context.State = new ConcreteStateA();  
86.     }  
87. }  

结构图：

应用实例： 电灯有两个状态，开（亮）与关（不亮），下面就用状态模式来实现对电灯的控制。

[csharp]  view plain  copy

1. using UnityEngine;  
2. using System.Collections;  
3.   
4. public class TestLight : MonoBehaviour {  
5.   
6.     // Use this for initialization  
7.     void Start () {  
8.         // 初始化电灯，原始状态为关  
9.         Light light = new Light(new Off());  
10.   
11.         // 第一次按下开关，打开电灯  
12.         light.PressSwich();  
13.         // 第二次按下开关，关闭电灯  
14.         light.PressSwich();  
15.     }  
16.       
17. }  
18.   
19. /// <summary>  
20. /// 电灯类，对应模式中的Context类  
21. /// </summary>  
22. public class Light  
23. {  
24.     private LightState state;  
25.   
26.     public Light(LightState state)  
27.     {  
28.         this.state = state;  
29.     }  
30.   
31.     /// <summary>  
32.     /// 按下电灯开关  
33.     /// </summary>  
34.     public void PressSwich()  
35.     {  
36.         state.PressSwich(this);  
37.     }  
38.   
39.     public LightState State  
40.     {  
41.         get { return state; }  
42.         set { state = value; }  
43.     }  
44. }  
45.   
46. /// <summary>  
47. /// 抽象的电灯状态类，相当于State类  
48. /// </summary>  
49. public abstract class LightState  
50. {  
51.     public abstract void PressSwich(Light light);  
52. }  
53.   
54. /// <summary>  
55. /// 具体状态类, 开  
56. /// </summary>  
57. public class On : LightState  
58. {  
59.     /// <summary>  
60.     /// 在开状态下，按下开关则切换到关的状态。  
61.     /// </summary>  
62.     /// <param name="light"></param>  
63.     public override void PressSwich(Light light)  
64.     {  
65.         Debug.Log("Turn off the light.");  
66.   
67.         light.State = new Off();  
68.     }  
69. }  
70.   
71. /// <summary>  
72. /// 具体状态类，关  
73. /// </summary>  
74. public class Off : LightState  
75. {  
76.     /// <summary>  
77.     /// 在关状态下，按下开关则打开电灯。  
78.     /// </summary>  
79.     /// <param name="light"></param>  
80.     public override void PressSwich(Light light)  
81.     {  
82.         Debug.Log("Turn on the light.");  
83.   
84.         light.State = new On();  
85.     }  
86. }  

转：https://blog.csdn.net/qq563129582/article/details/53695853