什么是状态模式

允许一个对象在其内部状态发生改变时改变其行为，使这个对象看上去就像改变了它的类型一样。
状态即事物所处的某一种形态。状态模式是说一个对象在其内部状态发生改变时，其表现的行为和外在属性不一样，这个对象看上去就像改变了它的类型一样。因此状态模式又称为对象的行为模式。

状态模式设计思想

水有三种不同状态，冰、水、水蒸气。三种不同状态有完全不一样的外在特征：冰坚硬、水具有流动性，水蒸气，质轻。
状态模式的核心思想就是一个事物(对象)有多种状态，在不同的状态下所表现出来的行为和属性不一样。

代码:

  2. """
  3. 故事案例以水为例
  4. """
  7. class Water:
  8.     """水"""
  9.     def __init__(self, state):
  10.         self.__temp = 25
  11.         self.__state = state
  13.     def change_state(self, state):
  14.         if self.__state:
  15.             print('由', self.__state.get_name(), '变为', state.get_name())
  16.         else:
  17.             print('初始状态', state.get_name())
  18.         self.__state = state
  20.     def get_temp(self):
  21.         return self.__temp
  23.     def set_temp(self, temp):
  24.         self.__temp = temp
  25.         if self.__temp < 0:
  26.             self.change_state(SolidState('固态'))
  27.         elif self.__temp < 100:
  28.             self.change_state(LiquidState('液态'))
  29.         else:
  30.             self.change_state(GaseousState('气态'))
  32.     def rise_temp(self, step):
  33.         self.set_temp(self.__temp + step)
  35.     def reduce_temp(self, step):
  36.         self.set_temp(self.__temp - step)
  38.     def behavior(self):
  39.         self.__state.behavior(self)
  42. class State:
  43.     def __init__(self, name):
  44.         self.__name = name
  46.     def get_name(self):
  47.         return self.__name
  49.     def behavior(self, water):
  50.         """不同状态下的行为"""
  51.         pass
  54. class SolidState(State):
  55.     """固态"""
  56.     def __init__(self, name):
  57.         super().__init__(name)
  59.     def behavior(self, water):
  60.         print('我是的温度是' + str(water.get_temp()))
  63. class LiquidState(State):
  64.     """液态"""
  65.     def __init__(self, name):
  66.         super().__init__(name)
  68.     def behavior(self, water):
  69.         print('我是的温度是' + str(water.get_temp()))
  72. class GaseousState(State):
  73.     """气态"""
  74.     def __init__(self, name):
  75.         super().__init__(name)
  77.     def behavior(self, water):
  78.         print('我是的温度是' + str(water.get_temp()))
  81. if __name__ == '__main__':
  82.     water = Water(LiquidState('液态'))
  83.     water.behavior()
  84.     water.set_temp(-5)
  85.     water.behavior()
  86.     water.set_temp(1000)
  87.     water.behavior()

代码架构

注意事项：1.水的状态有很多种，2.对于多种状态怎么判断3.类的状态的类只能有一种，不可固态1， 固态2，所以状态类要使用单例模式。

基本框架的实现

代码：

  2. class Context:
  3.     """状态模式的上下文环境"""
  5.     def __init__(self):
  6.         self.__states = []
  7.         self.__cur_state = None
  8.         # 状态改变依赖的属性，当这个变量由多个变量共同决定时可以将其单独定义成一个类
  9.         self.__state_info = 0
  11.     def add_state(self, state):
  12.         if state not in self.__states:
  13.             self.__states.append(state)
  15.     def get_state(self):
  16.         return self.__cur_state
  18.     def change_state(self, state):
  19.         if state is None:
  20.             return False
  21.         if self.__cur_state is None:
  22.             print('初始状态', state.get_name())
  23.         else:
  24.             print('由', self.__cur_state.get_name(), '转变', state.get_name())
  25.         self.__cur_state = state
  26.         self.add_state(state)
  27.         return True
  29.     def _set_state_info(self, state_info):
  30.         self.__state_info = state_info
  31.         for state in self.__states:
  32.             if state.is_match(state_info):
  33.                 self.change_state(state)
  35.     def get_state_info(self):
  36.         return self.__state_info
  39. class State:
  40.     """状态的基类"""
  41.     def __init__(self, name):
  42.         self.__name = name
  44.     def get_name(self):
  45.         return self.__name
  47.     def is_match(self, state_info):
  48.         "状态的属性state_info是否存在当前的状态范围"
  49.         return False
  52. class Water(Context):
  53.     def __init__(self):
  54.         super().__init__()
  55.         self.add_state(SolidState('固态'))
  56.         self.add_state(LiquidState('液态'))
  57.         self.add_state(GaseousState('气态'))
  59.     def set_temp(self, temp):
  60.         self._set_state_info(temp)
  62.     def get_temp(self):
  63.         return self.get_state_info()
  65.     def rise_temp(self, step):
  66.         self.set_temp(self.get_state_info() + step)
  68.     def reduce_temp(self, step):
  69.         self.set_temp(self.get_state_info() - step)
  71.     def behavior(self):
  72.         state = self.get_state()
  73.         if isinstance(state, State):
  74.             state.behavior(self)
  77. # 单例模式装饰器
  78. def singleton(cls, *args, **kwargs):
  79.     instance = {}
  81.     def __singleton(*args, **kwargs):
  82.         if cls not in instance:
  83.             instance[cls] = cls(*args, **kwargs)
  84.             return instance[cls]
  86.     return __singleton
  89. @singleton
  90. class SolidState(State):
  91.     """固体"""
  92.     def __init__(self, name):
  93.         super().__init__(name)
  95.     def is_match(self, state_info):
  96.         return state_info < 0
  98.     def behavior(self, context):
  99.         print('我是固态温度是%s' % context.get_state_info())
  102. @singleton
  103. class LiquidState(State):
  104.     """液态"""
  106.     def __init__(self, name):
  107.         super().__init__(name)
  109.     def is_match(self, state_info):
  110.         return state_info >=0 and state_info < 100
  112.     def behavior(self, context):
  113.         print('我是液体温度是%s' % context.get_state_info())
  116. @singleton
  117. class GaseousState(State):
  118.     """气态"""
  119.     def __init__(self, name):
  120.         super().__init__(name)
  122.     def is_match(self, state_info):
  123.         return state_info > 100
  125.     def behavior(self, context):
  126.         print('我是气态温度是%s' % context.get_state_info())
  129. if __name__ == '__main__':
  130.     water = Water()
  131.     water.behavior()
  132.     water.set_temp(-5)
  133.     water.behavior()
  134.     water.set_temp(1000)
  135.     water.behavior()

模型说明

设计要点

在实现状态模式的时候，实现的场景状态有时候会非常复杂，决定状态变化的因素也非常多，我们可以把决定状态变化的属性单独抽象成一个类StateInfo,这样判断状态属性是否符合当前的状态is_match时传入更多的信息。
每种状态应当只有唯一实例。

状态模型的优缺点

优点：

封装状态的转换规则，在状态模式中可以将状态的转换代码封装在环境类中，对状态转换代码进行集中管理，而不是分散在一个个业务逻辑中。
将所有与某个状态有关的行为放到一个类中(称为状态类)，使开发人员只专注与该状态下的逻辑开发。
允许状态转换逻辑与状态对象合为一体，使用时只需要注入一个不同的状态对象即可使环境对象拥有不同的行为。

缺点：

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

应用场景

一个对象的行为取决于它的状态，并且它在运行时可能会经常改变它的状态，从而改变它的行为。
一个操作中含有庞大的多分支条件语句，这些分支依赖与该对象的状态，并且每个分支的业务逻辑都非常的复杂，我们可以用状态模式来拆分不同的分支逻辑，使程序有更好的可读性和可维护性。