java-design-patterns/state/README.md

title, category, language, tags

title	category	language	tags
State	Behavioral	en	Gang of Four

Also known as

Objects for States

Intent

Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.

Explanation

Real-world example

When observing a mammoth in its natural habitat it seems to change its behavior based on the situation. It may first appear calm, but over time when it detects a threat, it gets angry and dangerous to its surroundings.

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

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.

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.

    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.

Class diagram

Applicability

Use the State pattern in either of the following cases

• An object's behavior depends on its state, and it must change its behavior at run-time depending on that state
• Operations have large, multipart conditional statements that depend on the object's state. This state is usually represented by one or more enumerated constants. Often, several operations will contain this same conditional structure. The State pattern puts each branch of the conditional in a separate class. This lets you treat the object's state as an object in its own right that can vary independently from other objects.

Known uses

• javax.faces.lifecycle.Lifecycle#execute() controlled by FacesServlet, the behavior is dependent on current phase of lifecycle.
• JDiameter - Diameter State Machine

Credits

• Design Patterns: Elements of Reusable Object-Oriented Software
• Head First Design Patterns: A Brain-Friendly Guide
• Refactoring to Patterns