设计模式：状态模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）-CSDN博客
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
简介
状态模式它是一种对象行为型模式它允许一个对象在其内部状态改变时改变它的行为。这种模式可以让一个对象的行为随着状态的改变而改变增强了代码的可维护性和灵活性。
在状态模式中通常有一个状态的接口以及一些具体状态类。这些具体状态类实现了状态的接口并定义了在该状态下对象的行为。上下文类则包含一个状态对象并定义了如何改变状态的方法。在上下文类中根据当前状态和请求可以调用当前状态的 Handle 方法来处理请求并更新状态。
状态模式的使用场景
1、一个对象存在多个状态状态可以相互转换。
2、不同状态下行为不同。
3、代码中包含大量与对象状态有关的 if/else 或 switch case 语句且这些条件执行与否依赖于该对象的状态。
状态模式的创建步骤
1、创建一个接口表示状态的抽象。
2、创建实现接口的实体类表示具体状态。
3、创建一个上下文类包含一个状态对象并定义如何改变状态的方法。
4、在上下文类中根据当前状态和请求调用当前状态的 Handle 方法来处理请求并更新状态。
以上是状态模式的基本创建步骤您可以根据实际应用场景进行调整和扩展。
状态模式的优点主要包括
1、封装了状态的转换规则将状态的转换代码封装在环境类或者具体状态类中集中管理状态转换代码而不是分散在一个个业务方法中。
2、将所有与某个状态有关的行为放到一个类中只需要注入一个不同的状态对象即可使环境对象拥有不同的行为。
3、允许状态转换逻辑与状态对象合成一体而不是提供一个巨大的条件语句块从而避免将业务方法和状态转换代码交织在一起。
4、可以让多个环境对象共享一个状态对象从而减少系统中对象的个数。
状态模式的缺点主要包括
1、类膨胀如果一个事物具备很多状态则会造成状态类太多导致系统复杂度增加。
2、状态模式的结构与实现都较为复杂如果使用不当将导致程序结构和代码的混乱。
3、状态模式对开闭原则的支持不太好对于可以切换状态的状态模式增加新的状态类需要修改那些负责状态转换的源代码否则无法切换到新增状态。
4、如果状态数量比较多状态类的数量会增加业务场景系统变得很复杂。
示例
一、C#状态模式
以下是一个示例展示了如何在C#中实现状态模式
//首先定义一个状态的接口
public interface State
{
void Handle(Context context);
}
//然后定义一些具体的状态
public class StateA : State
{
public void Handle(Context context)
{
Console.WriteLine("State A handled. Switching to State B");
context.State = new StateB();
}
}
public class StateB : State
{
public void Handle(Context context)
{
Console.WriteLine("State B handled. Switching to State A");
context.State = new StateA();
}
}
//然后定义一个上下文Context类它包含一个状态对象并定义如何改变状态的方法
public class Context
{
private State _state;
public Context(State state)
{
this._state = state;
}
public State State { get { return _state; } }
public void Request() => _state.Handle(this);
}
//最后在主函数中使用
public static void Main(string[] args)
{
var stateA = new StateA();
var context = new Context(stateA);
context.Request();
}二、java状态模式
状态模式通常通过以下方式实现
//首先定义一个状态的接口
public interface State {
void handle(Context context);
}
//然后定义一些具体的状态
public class StateA implements State {
@Override
public void handle(Context context) {
System.out.println("State A handled. Switching to State B");
context.setState(new StateB());
}
}
public class StateB implements State {
@Override
public void handle(Context context) {
System.out.println("State B handled. Switching to State A");
context.setState(new StateA());
}
}
//然后定义一个上下文Context类它包含一个状态对象并定义如何改变状态的方法
public class Context {
private State state;
public Context(State state) {
this.state = state;
}
public void request() {
state.handle(this);
}
public void setState(State state) {
this.state = state;
}
}
//最后在主函数中使用
public static void main(String[] args) {
StateA stateA = new StateA();
Context context = new Context(stateA);
context.request();
}三、javascript状态模式
在JavaScript中状态实现方式如下
class Context {
constructor(state) {
this.state = state;
}
request() {
this.state.handle(this);
}
}
class State {
handle(context) {
console.log("Default state handled");
}
}
class StateA extends State {
handle(context) {
console.log("State A handled. Switching to State B");
context.state = new StateB();
}
}
class StateB extends State {
handle(context) {
console.log("State B handled. Switching to State A");
context.state = new StateA();
}
}
const stateA = new StateA();
const context = new Context(stateA);
context.request(); 四、C++状态模式
以下是在C++中实现状态模式
#include <iostream>
#include <string>
class Context {
public:
void Request() {
m_state->Handle(this);
}
private:
State* m_state;
};
class State {
public:
virtual void Handle(Context* context) = 0;
};
class StateA : public State {
public:
void Handle(Context* context) override {
std::cout << "State A handled. Switching to State B" << std::endl;
context->m_state = new StateB();
}
};
class StateB : public State {
public:
void Handle(Context* context) override {
std::cout << "State B handled. Switching to State A" << std::endl;
context->m_state = new StateA();
}
};
int main() {
StateA* stateA = new StateA();
Context context(stateA);
context.Request();
}五、python状态模式
以下是在python中实现状态模式
from abc import ABC, abstractmethod
class Context(ABC):
@abstractmethod
def Request(self):
pass
class State(ABC):
@abstractmethod
def Handle(self, context):
pass
class StateA(State):
def Handle(self, context):
print("State A handled. Switching to State B")
context.State = StateB()
class StateB(State):
def Handle(self, context):
print("State B handled. Switching to State A")
context.State = StateA()
class Context(Context):
def __init__(self, state):
self.State = state
def Request(self):
self.State.Handle(self)六、go状态模式
以下是一个示例展示了如何在go中实现状态模式
// State 接口定义了每个状态必须实现的方法
type State interface {
Handle(context *Context)
}
// ConcreteStateA 是 State 接口的具体实现
type ConcreteStateA struct{}
func (s *ConcreteStateA) Handle(context *Context) {
fmt.Println("State A handled. Switching to State B")
context.State = &ConcreteStateB{}
}
// ConcreteStateB 是 State 接口的具体实现
type ConcreteStateB struct{}
func (s *ConcreteStateB) Handle(context *Context) {
fmt.Println("State B handled. Switching to State A")
context.State = &ConcreteStateA{}
}
// Context 是包含状态的对象的结构体
type Context struct {
State State
}
func (c *Context) Request() {
c.State.Handle(c)
}七、PHP状态模式
以下是一个示例展示了如何在PHP中实现状态模式
<?php
interface State {
public function handle();
}
class ConcreteStateA implements State {
public function handle() {
echo "State A handled. Switching to State B\n";
$this->context->setState(new ConcreteStateB());
}
}
class ConcreteStateB implements State {
public function handle() {
echo "State B handled. Switching to State A\n";
$this->context->setState(new ConcreteStateA());
}
}
class Context {
private $state;
public function setState(State $state) {
$this->state = $state;
}
public function request() {
$this->state->handle();
}
}
// 使用状态模式示例代码
$context = new Context();
$context->setState(new ConcreteStateA());
《完结》