欢迎来到尧图网

客户服务 关于我们

您的位置:首页 > 科技 > 名人名企 > 【设计模式】【行为型模式(Behavioral Patterns)】之状态模式(State Pattern)

【设计模式】【行为型模式(Behavioral Patterns)】之状态模式(State Pattern)

2024/11/29 17:31:15 来源:https://blog.csdn.net/ido1ok/article/details/144061259  浏览:    关键词:【设计模式】【行为型模式(Behavioral Patterns)】之状态模式(State Pattern)

1. 设计模式原理说明

状态模式(State Pattern) 是一种行为设计模式,它允许对象在其内部状态发生变化时改变其行为。这个模式的核心思想是使用不同的类来表示不同的状态,每个状态类都封装了与该状态相关的特定行为。当对象的状态发生改变时,对象会切换到另一个状态对象,从而改变了它的行为。

主要角色
  1. Context(上下文):定义客户感兴趣的接口,维护一个对当前状态对象的引用。
  2. State(抽象状态):定义一个接口,用以封装与Context的一个特定状态相关的行为。
  3. ConcreteState(具体状态):实现State接口,每种状态都对应一个具体的状态类,封装了与该状态相关的特定行为。

2. UML 类图及解释

UML 类图
+-----------------+
|     Context     |
|-----------------|
| - state: State  |
| + setState(state: State) |
| + request()     |
+-----------------+^||v
+-----------------+
|     State       |
|-----------------|
| + handle(context: Context) |
+-----------------+^||v
+-----------------+
| ConcreteStateA  |
|-----------------|
| + handle(context: Context) |
+-----------------+^||v
+-----------------+
| ConcreteStateB  |
|-----------------|
| + handle(context: Context) |
+-----------------+
类图解释
  • Context:定义客户感兴趣的接口,维护一个对当前状态对象的引用。当状态变化时,调用setState方法更新当前状态。
  • State:定义一个接口,用以封装与Context的一个特定状态相关的行为。
  • ConcreteStateA 和 ConcreteStateB:实现State接口,每种状态都对应一个具体的状态类,封装了与该状态相关的特定行为。

3. 代码案例及逻辑详解

Java 代码案例
// 抽象状态
interface State {void handle(Context context);
}// 具体状态 A
class ConcreteStateA implements State {@Overridepublic void handle(Context context) {System.out.println("Current state is ConcreteStateA");context.setState(new ConcreteStateB());}
}// 具体状态 B
class ConcreteStateB implements State {@Overridepublic void handle(Context context) {System.out.println("Current state is ConcreteStateB");context.setState(new ConcreteStateA());}
}// 上下文
class Context {private State state;public Context(State state) {this.state = state;}public void setState(State state) {this.state = state;}public void request() {state.handle(this);}
}// 客户端
public class Client {public static void main(String[] args) {Context context = new Context(new ConcreteStateA());context.request();  // 输出: Current state is ConcreteStateAcontext.request();  // 输出: Current state is ConcreteStateB}
}
C++ 代码案例
#include <iostream>// 抽象状态
class State {
public:virtual void handle(Context* context) = 0;
};// 具体状态 A
class ConcreteStateA : public State {
public:void handle(Context* context) override {std::cout << "Current state is ConcreteStateA" << std::endl;context->setState(new ConcreteStateB());}
};// 具体状态 B
class ConcreteStateB : public State {
public:void handle(Context* context) override {std::cout << "Current state is ConcreteStateB" << std::endl;context->setState(new ConcreteStateA());}
};// 上下文
class Context {
private:State* state;
public:Context(State* state) : state(state) {}void setState(State* state) {delete this->state;this->state = state;}void request() {state->handle(this);}
};// 客户端
int main() {Context* context = new Context(new ConcreteStateA());context->request();  // 输出: Current state is ConcreteStateAcontext->request();  // 输出: Current state is ConcreteStateBdelete context;return 0;
}
Python 代码案例
# 抽象状态
class State:def handle(self, context):pass# 具体状态 A
class ConcreteStateA(State):def handle(self, context):print("Current state is ConcreteStateA")context.set_state(ConcreteStateB())# 具体状态 B
class ConcreteStateB(State):def handle(self, context):print("Current state is ConcreteStateB")context.set_state(ConcreteStateA())# 上下文
class Context:def __init__(self, state):self.state = statedef set_state(self, state):self.state = statedef request(self):self.state.handle(self)# 客户端
if __name__ == "__main__":context = Context(ConcreteStateA())context.request()  # 输出: Current state is ConcreteStateAcontext.request()  # 输出: Current state is ConcreteStateB
Go 代码案例
package mainimport ("fmt"
)// 抽象状态
type State interface {handle(context *Context)
}// 具体状态 A
type ConcreteStateA struct{}func (s *ConcreteStateA) handle(context *Context) {fmt.Println("Current state is ConcreteStateA")context.setState(&ConcreteStateB{})
}// 具体状态 B
type ConcreteStateB struct{}func (s *ConcreteStateB) handle(context *Context) {fmt.Println("Current state is ConcreteStateB")context.setState(&ConcreteStateA{})
}// 上下文
type Context struct {state State
}func (c *Context) setState(state State) {c.state = state
}func (c *Context) request() {c.state.handle(c)
}// 客户端
func main() {context := &Context{state: &ConcreteStateA{}}context.request()  // 输出: Current state is ConcreteStateAcontext.request()  // 输出: Current state is ConcreteStateB
}

4. 总结

状态模式 是一种行为设计模式,它允许对象在其内部状态发生变化时改变其行为。这个模式的核心思想是使用不同的类来表示不同的状态,每个状态类都封装了与该状态相关的特定行为。当对象的状态发生改变时,对象会切换到另一个状态对象,从而改变了它的行为。

主要优点
  1. 简化对象的操作:将与特定状态相关的行为封装在状态对象中,使上下文对象的操作更加简单。
  2. 高内聚低耦合:状态对象之间的转换逻辑被封装在状态对象内部,减少了上下文对象的复杂性。
  3. 易于扩展:新增状态时,只需添加新的状态类,而不需要修改现有的代码。
主要缺点
  1. 类的膨胀:每增加一个新的状态就需要增加一个新的类,可能导致类的数量急剧增加。
  2. 状态转换逻辑复杂:状态之间的转换逻辑可能变得复杂,尤其是当状态数量较多时。
适用场景
  • 当一个对象的行为取决于它的状态,并且它必须在运行时根据状态改变其行为时。
  • 当控制一个对象的状态转换的条件表达式过于复杂时。
  • 当代码中包含大量与对象状态有关的条件语句时,可以考虑使用状态模式来简化这些条件语句。

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com