State Design Pattern

The State Design Pattern is used in system design to allow an object to alter its behavior when its internal state changes, effectively making the object appear to change its class.
🔄 Core Intent:
Allow an object to change its behavior when its state changes.”
✅ Use Case in System Design: a system must behave differently based on its current state, and state-specific behavior is scattered across many conditional statements (`if`, `switch`), the State pattern offers a clean solution.
🧱 Key Components:

1. Context: The class that contains a reference to a State object and delegates state-specific behavior to it.
2. State Interface: Declares the behavior that changes depending on the state.
3. Concrete States: Implement state-specific behavior.

⚙️ How It's Used – Example:
Suppose you're building a "media player" with states: `Playing`, `Paused`, and `Stopped`.

// State interface
interface PlayerState {
    void pressPlay(MediaPlayer context);
}

// Concrete States
class PlayingState implements PlayerState {
    public void pressPlay(MediaPlayer context) {
        System.out.println("Pausing playback...");
        context.setState(new PausedState());
    }
}

class PausedState implements PlayerState {
    public void pressPlay(MediaPlayer context) {
        System.out.println("Resuming playback...");
        context.setState(new PlayingState());
    }
}

// Context
class MediaPlayer {
    private PlayerState state;
    
    public MediaPlayer() {
        state = new StoppedState();
    }

    public void setState(PlayerState state) {
        this.state = state;
    }

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

🎯 Why Use It in System Design?

• Eliminates large conditionals for state transitions.
• Makes state transitions explicit and encapsulated.
• Improves scalability: new states can be added without modifying existing logic.
• Encourages Single Responsibility Principle each state handles its own logic.

🧠 Real-World Analogies:

• TCP Connection: Can be in states like Established, Listening, or Closed.
• Workflow Engines: Each document or request goes through states like Draft, Submitted, Approved, Rejected.

When an object exhibits a lot of state-specific behavior the code can become large, complex, and difficult to follow. For each behavior that the object can manifest, the implementation may be different for each state of the object. For example, a relatively simple object with six states and six behaviors would require 36 blocks of implementation code, one block of code for each behavior for each state.
View the image below to see an example of this.

State Pattern One technique for coping with the complexity of state-specific behavior is the state design pattern. This pattern uses the concept of delegation to separate the implementation of a behavior from the object that is responsible for the behavior. For example, most of us are responsible for filing taxes. However, for some of us, the process is extremely complex and requires assistance from an expert. We retain ultimate responsibility for filing the taxes, but we delegate the actual process to a specialist who does it for us. When the tax specialist is finished, he/she returns the results to us. View the diagram below to see the key components of the state design pattern.

When an object's behaviors differ depending on the object's state, you can define new objects that represent the object's state. Each unique state object type has its own implementation for each behavior. When the object needs a behavior it "delegates" the behavior to the appropriate state object. Once the behavior has been completed, the state object returns control to the original object. Let us look at a Java example:

void SubmitClaim(Claim) { 
  state.SubmitClaim(Claim) 
}

Note how the operation simply invokes another operation of the same name on the object referred to by the state attribute. The interface does not really even have an implementation of its own.

The statechart diagram provides an explicit description of the states of an object. To create the state pattern in your class diagram view the series of images below and follow the steps.

The state pattern is not appropriate for every application of state-specific behavior. However, when you are faced with increasing numbers of states and a variety of behaviors, the pattern can pay huge dividends in ease of maintenance and understandability.