How to use Java state design pattern to implement object state transition

Introduction

Java State Pattern (State Pattern) is an object-oriented design pattern, which encapsulates the state of an object into an independent state object and decouples the behavior of the object from the state object. Allows an object to change its behavior when its internal state changes. This pattern encapsulates the object's behavior in different state objects instead of putting all behaviors in a class.

Java State Pattern The general industry is composed of the following three roles:

• State Interface (State Interface): defines a set of methods related to context objects, which will be implemented by specific objects in different states. .

• Concrete State: Implements the state interface, and the specific state object is a different state implementation.

• Context (Context) : An object with multiple states. The context object can change the state at runtime, thereby changing its behavior.

It should be noted that there are many ways to implement the Java state pattern, For example, use interfaces and abstract classes to implement states, use enumerations to implement states, etc. The specific implementation method depends on the specific needs and scenarios.

Implementation

Suppose we have a simple game, the game The protagonist in can perform different operations in different states. We can use the state pattern to implement the design of this game.

State interface

public interface State {
    /**
     * 移动
     */
    void move();
    /**
     * 攻击
     */
    void attack();
}

Specific state

public class IdleState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("静止状态下不能移动...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("静止状态下不能攻击...");
    }
}
public class MoveState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("移动中...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("移动状态下不能攻击...");
    }
}
public class AttackState implements State{
    /**
     * 移动
     */
    @Override
    public void move() {
        System.out.println("攻击状态下不能移动...");
    }
    /**
     * 攻击
     */
    @Override
    public void attack() {
        System.out.println("攻击中...");
    }
}

Context

public class Context {
    private State state;
    public Context() {
        // 默认静止状态
        this.state = new IdleState();
    }
    public void setState(State state) {
        this.state = state;
    }
    /**
     * 移动
     */
    public void move() {
        state.move();
    }
    /**
     * 攻击
     */
    public void attack() {
        state.attack();
    }
}

Test

public class Demo {
    public static void main(String[] args) {
        // 静止状态
        Context context = new Context();
        context.move();
        context.attack();
        // 移动状态
        context.setState(new MoveState());
        context.move();
        context.attack();
        // 攻击状态
        context.setState(new AttackState());
        context.move();
        context.attack();
    }
}

In the above example, first we define a State interface, and then we define three specific state classes, IdleState , MoveState and AttackState respectively represent the protagonist's idle state, moving state and attack state. These states all implement the State interface. Next we define a context Context, which contains a State object representing the current state. In the Context class , we define a setState method for changing the state, and the move and attack methods for performing corresponding operations.

Summary

Advantages

• The state mode makes it easy to add a state, just add a new state class.

• The state mode makes the state of the object by encapsulating the state transition logic in the state class. Changes are more clear and clear.

• The state mode makes state switching easier, just call the object's state transition method.

Disadvantages

• The state mode will cause the number of classes in the system to increase and increase the complexity of the code.

• The state mode may cause state switching The process becomes complicated.

Application scenarios

• When the behavior of an object depends on its state, and the state can change at runtime The state pattern is a good choice.

• The state pattern is very useful when an object needs to perform different operations based on its state.

• When you need to dynamically add new behaviors to objects, the state pattern is a good choice.

Some common application scenarios include: order status; user login Status; game status, etc.

The above is the detailed content of How to use Java state design pattern to implement object state transition. For more information, please follow other related articles on the PHP Chinese website!