Java行为型设计模式-状态模式（含电梯场景示例）

标签：状态 Java 示例 void state elevator State 设计模式 public

1. 状态模式简介

状态模式（State Pattern）是一种行为型设计模式，它允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。状态模式的目的是让状态转换显式，并且使得状态转换代码集中在一个地方，不需要使用多重条件语句。

状态模式（State Pattern）用于解决系统中对象的行为依赖于其状态变化的问题。在状态模式中，我们将每一个状态转换到另一个状态的行为封装在一个状态类中。

2. 状态模式角色

通过这种设计模式，可以将对象的行为分散到各个具体状态类中，使得系统更加灵活和可扩展。当对象的行为随着对象所处的状态改变时，可以通过改变对象的状态来实现行为的变化，而不是通过复杂的条件语句来控制。这种方式简化了代码，提高了代码的可读性和可维护性‌。

Java设计模式中的状态模式包括三个主要角色：环境类（Context）、抽象状态类（State）和具体状态类（Concrete State）。‌

‌2.1 环境类（Context）‌

环境类是拥有状态的对象，它根据当前状态执行相应的行为。环境类维护了一个对抽象状态类的引用，用于切换和委托不同的状态处理。环境类通常包含设置状态、请求等方法，通过这些方法，环境类可以与具体状态类进行交互，实现状态的切换和行为的变化。

‌2.2 抽象状态类（State）‌

抽象状态类定义了一个接口，用于具体状态类的实现。在这个接口中声明了具体状态类需要实现的方法，这些方法定义了状态的行为。抽象状态类是具体状态类的共同接口，它规定了具体状态类必须实现的方法，从而确保了所有具体状态类的一致性和可互换性。

‌2.3 具体状态类（Concrete State）‌

具体状态类实现了抽象状态类的接口，并负责定义该状态下的具体行为。每个具体状态类都实现了抽象状态类中定义的方法，从而定义了在特定状态下的行为。具体状态类可以根据需要切换环境类的状态，通过这种方式，对象可以根据其当前状态来改变行为，而不需要使用大量的条件判断语句。

3. 状态模式使用场景

Java中的状态模式适用于那些需要根据内部状态改变对象行为的场景。‌

状态模式的主要应用场景包括但不限于：‌‌

3.1 电梯控制系统

电梯可以根据当前状态（停止、上升、下降等）执行相应的操作，如改变运行方向或停止。通过状态模式，电梯的状态转换逻辑可以被清晰地定义和管理，从而提高系统的可维护性。

‌‌3.2 金融交易系统

在金融交易系统中，账户可能处于不同的状态，如未激活、正常、冻结等。根据账户的状态，系统会执行不同的操作，如转账、提现等。状态模式可以帮助管理这些状态的转换，确保系统行为与账户状态保持一致。

‌‌3.3 游戏开发‌

在游戏开发中，角色或物体可能有多种状态，如攻击状态、防御状态、移动状态等。根据当前状态，角色会执行不同的动作或技能。状态模式可以很好地管理这些状态的转换，使得游戏逻辑更加清晰和易于维护。

‌‌3.4 软件中的状态管理‌

在复杂的软件系统中，对象可能需要根据其内部状态执行不同的操作。例如，一个用户可能处于登录状态或未登录状态，根据这些状态，软件会提供不同的功能或界面。状态模式可以帮助管理这些状态的转换，确保软件行为与用户状态保持一致。

通过将对象的状态和行为分离，状态模式使得代码更加模块化，易于理解和维护。它通过定义一系列的状态类和状态转换逻辑，允许对象在其生命周期内根据需要改变其行为，从而适应不同的应用场景‌。

4. 状态模式代码示例（简单demo）

以下是一个简单的状态模式的 Java 示例代码：

4.1 编写状态接口

抽象状态类定义了一个接口，用于具体状态类的实现：

// 状态接口
interface State {
    void doAction(Context context);
}

4.2 编写状态实现类（状态类）

具体状态类实现了抽象状态类的接口，并负责定义该状态下的具体行为：

// 状态类
class ConcreteStateA implements State {
    public void doAction(Context context) {
        System.out.println("Curren State is A.");
        // 根据环境类的内部状态变化到状态 B
        context.setState(new ConcreteStateB());
    }
}
 
class ConcreteStateB implements State {
    public void doAction(Context context) {
        System.out.println("Curren State is B.");
        // 根据环境类的内部状态变化到状态 A
        context.setState(new ConcreteStateA());
    }
}

4.3 编写环境类

// 环境类
class Context {
    private State state;
 
    public Context(State state) {
        this.state = state;
    }
 
    public void setState(State state) {
        this.state = state;
    }
 
    public void request() {
        // 根据当前状态执行行为
        state.doAction(this);
    }
}

4.4 客户端代码

// 客户端代码
public class StatePatternExample {
    public static void main(String[] args) {
        // 初始状态设置为 A
        Context context = new Context(new ConcreteStateA());
        
        // 客户端请求，将触发状态 A 的行为
        context.request();
        // 输出 Curren State is A.
        
        // 状态 A 将状态改变到状态 B
        context.request();
        // 输出 Curren State is B.
        
        // 状态 B 将状态改变回状态 A
        context.request();
        // 输出 Curren State is A.
    }
}

在这个示例中，Context 类维护了一个 State 实例，并提供了一个 request 方法来触发当前状态的行为。State 接口定义了一个 doAction 方法，所有状态类需要实现这个方法来定义其行为。根据业务需求，Context 类的 request 方法可以在任何时候被调用，并且会根据当前的状态来执行不同的行为。这样的设计模式使得状态转换和相关行为的代码更加清晰和模块化。

5. 状态模式代码示例（电梯状态转换）

5.1 电梯的状态接口

// 电梯的状态接口
interface ElevatorState {
    void openDoors();
    void closeDoors();
    void gotRequest(ElevatorRequest request);
    void stop();
}

5.2 电梯业务请求类

该类用于封装用户对电梯发起的请求参数。

class ElevatorRequest {
    int floor;
    boolean isUp;
 
    ElevatorRequest(int floor, boolean isUp) {
        this.floor = floor;
        this.isUp = isUp;
    }
}

5.3 电梯类（上下文环境）

该类用于封装电梯的基本功能，即上下文环境，用于接收用户请求，然后根据请求执行对用的业务接口！

// 电梯类
class Elevator {
    ElevatorState state;
 
    public Elevator() {
        this.state = new ClosingState(this);
    }
 
    void setState(ElevatorState state) {
        this.state = state;
    }
 
    void openDoors() {
        state.openDoors();
    }
 
    void closeDoors() {
        state.closeDoors();
    }
 
    void gotRequest(ElevatorRequest request) {
        state.gotRequest(request);
    }
 
    void stop() {
        state.stop();
    }
}

5.4 电梯功能状态实现

// 电梯状态实现类
class ClosingState implements ElevatorState {
    Elevator elevator;
 
    ClosingState(Elevator elevator) {
        this.elevator = elevator;
    }
 
    public void openDoors() {
        System.out.println("电梯门开启");
    }
 
    public void closeDoors() {
        System.out.println("电梯门关闭");
        elevator.setState(new StoppedState(elevator));
    }
 
    public void gotRequest(ElevatorRequest request) {
        // 实现请求处理逻辑
    }
 
    public void stop() {
        // 实现停止逻辑
    }
}
 
class StoppedState implements ElevatorState {
    Elevator elevator;
 
    StoppedState(Elevator elevator) {
        this.elevator = elevator;
    }
 
    // 其他方法的实现类似上面写法 略
}

5.7 客户端代码

// 使用示例
public class StatePatternExample {
    public static void main(String[] args) {
        Elevator elevator = new Elevator();
        elevator.openDoors();
        elevator.closeDoors();
        // 假设有请求处理逻辑
        elevator.gotRequest(new ElevatorRequest(5, true));
        elevator.stop();
    }
}

这个简单的例子展示了如何使用状态模式来实现电梯的状态切换。电梯有一个状态接口，电梯类维护一个当前状态的引用，并在需要时更新状态。每个状态实现了电梯可能的行为，并在必要时切换到另一个状态。这样的设计使得状态转换清晰且易于维护。

6. 状态模式优缺点

状态模式（State Pattern）是一种行为型设计模式，用于解决对象在不同状态下行为不同的问题。

6.1 优点

状态转换逻辑集中于状态对象中，易于维护和扩展。
避免了过于复杂的条件判断语句。
可以让多个环境共享一个状态对象。

6.2 缺点

状态模式可能导致系统中有过多的状态类。
状态模式增加了对象的数量，可能会增加系统的复杂性。

7. 总结

综上，状态模式（State Pattern）允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。状态模式的目的是让状态转换显式，并且使得状态转换代码集中在一个地方，不需要使用多重条件语句。

Java设计模式中的状态模式包括三个主要角色：环境类（Context）、抽象状态类（State）和具体状态类（Concrete State）。

标签：状态,Java,示例,void,state,elevator,State,设计模式,public
From： https://blog.csdn.net/lilinhai548/article/details/141460330