State Pattern in Java: Enhancing Behavior Dynamics with State Encapsulation

About 2 min

Also known as

Objects for States

Intent of State Design Pattern

Enable an object to alter its behavior dynamically as its internal state changes, optimizing Java application responsiveness.

Detailed Explanation of State Pattern with Real-World Examples

Real-world example

Imagine a traffic light system at an intersection. The traffic light can be in one of three states: Green, Yellow, or Red. Depending on the current state, the traffic light's behavior changes:
Green State: Cars are allowed to pass through the intersection.
Yellow State: Cars are warned that the light will soon turn red, so they should prepare to stop.
Red State: Cars must stop and wait for the light to turn green.
In this scenario, the traffic light uses the State design pattern. Each state (Green, Yellow, Red) is represented by a different object that defines what happens in that particular state. The traffic light (context) delegates the behavior to the current state object. When the state changes (e.g., from Green to Yellow), the traffic light updates its state object and changes its behavior accordingly.

In plain words

State pattern allows an object to change its behavior.

Wikipedia says

The state pattern is a behavioral software design pattern that allows an object to alter its behavior when its internal state changes. This pattern is close to the concept of finite-state machines. The state pattern can be interpreted as a strategy pattern, which is able to switch a strategy through invocations of methods defined in the pattern's interface.

Programmatic Example of State Pattern in Java

In our programmatic example there is a mammoth with alternating moods.

First, here is the state interface and its concrete implementations.

public interface State {

  void onEnterState();

  void observe();
}

@Slf4j
public class PeacefulState implements State {

  private final Mammoth mammoth;

  public PeacefulState(Mammoth mammoth) {
    this.mammoth = mammoth;
  }

  @Override
  public void observe() {
    LOGGER.info("{} is calm and peaceful.", mammoth);
  }

  @Override
  public void onEnterState() {
    LOGGER.info("{} calms down.", mammoth);
  }
}

@Slf4j
public class AngryState implements State {

  private final Mammoth mammoth;

  public AngryState(Mammoth mammoth) {
    this.mammoth = mammoth;
  }

  @Override
  public void observe() {
    LOGGER.info("{} is furious!", mammoth);
  }

  @Override
  public void onEnterState() {
    LOGGER.info("{} gets angry!", mammoth);
  }
}

And here is the mammoth containing the state. The state changes via calls to timePasses method.

public class Mammoth {

  private State state;

  public Mammoth() {
    state = new PeacefulState(this);
  }

  public void timePasses() {
    if (state.getClass().equals(PeacefulState.class)) {
      changeStateTo(new AngryState(this));
    } else {
      changeStateTo(new PeacefulState(this));
    }
  }

  private void changeStateTo(State newState) {
    this.state = newState;
    this.state.onEnterState();
  }

  @Override
  public String toString() {
    return "The mammoth";
  }

  public void observe() {
    this.state.observe();
  }
}

Here is the full example of how the mammoth behaves over time.

public static void main(String[] args) {

    var mammoth = new Mammoth();
    mammoth.observe();
    mammoth.timePasses();
    mammoth.observe();
    mammoth.timePasses();
    mammoth.observe();
}

Program output:

    The mammoth gets angry!
    The mammoth is furious!
    The mammoth calms down.
    The mammoth is calm and peaceful.

When to Use the State Pattern in Java

An object's behavior depends on its state, and it must change its behavior at runtime depending on that state.
Operations have large, multipart conditional statements that depend on the object's state.

Real-World Applications of State Pattern in Java

java.util.Iterator in Java's Collections Framework uses different states for iteration.
TCP connection classes in network programming often implement states like Established, Listen, and Closed.

Benefits and Trade-offs of State Pattern

Benefits:

Localizes state-specific behavior and partitions behavior for different states.
Makes state transitions explicit.
Reusable State objects can be efficiently shared among various contexts in Java, enhancing memory management and performance.

Trade-offs:

Can result in a large number of classes for states.
Context class can become complicated with the state transition logic.

Flyweight: State objects may be shared between different contexts.
Singleton: State objects are often singletons.
Strategy: Both patterns have similar structures, but the State pattern's implementations depend on the context’s state.