State Design Pattern

The State Design Pattern allows us to change the behaviour of an object based on it's current state. Sometimes we want a class to behave differently in different state, the pattern enables an object to appear as if it changes its class when its internal state changes, providing a clean and maintainable way to manage state-specific behavior.

In this tutorial, we'll explore the State Design Pattern in Java, covering its structure, implementation, best practices, and advantages.

Organization of the State Design Pattern

The State Design Pattern consists of the following components:
  • Context Entity: The entity acts as the class responsible for preserving an instance of a state subclass and assigning state-specific actions to that subclass.

  • State Module: The module serves as an interface or conceptual class outlining a series of methods embodying state-specific actions. Actual state classes either implement this interface or extend the conceptual class.

  • Specific Concrete Modules: Specific concrete modules are realizations of the state interface. Each particular module provides its unique interpretation of the state-specific actions laid out in the interface.
Important points about State pattern
  • State pattern allows the subject to vary its behaviour based on its current state.
  • Each state of the subject can be modelled as a class implementing a common State interface.
  • Each state object is responsible to performing state specific tasks.
  • A subject implements all behaviours which are independent of state and has a state object for performing state specific tasks.
  • The subject gets its state specific behaviour by delegating it to the current state object.
  • Whenever state of a system changes, its state object should also change to appropriate state handler.
  • Transition of state of subject can be handles by states or subject itself.
  • It is a behavioral design pattern.

Benefits of State Design Pattern

  • Effective Separation of Concerns : This approach ensures a clear distinction between the context and its states. Each state class encapsulates its behavior, fostering a modular and easy-to-maintain design..

  • Streamlined State-Specific Behavior : State-specific behavior is confined within individual state classes, simplifying comprehension and modification. Alterations to the behavior of one state have no impact on the behavior of other states.

  • Enhanced Clarity : The State Pattern improves code clarity by structuring state-specific behavior into distinct classes. This organization facilitates developers in locating and comprehending relevant code sections.

  • Supports Finite State Machines : This pattern is well-suited for implementing finite state machines, where an object undergoes transitions among a finite set of states. It offers a systematic approach to managing state-specific behavior in such systems.

  • Simple Addition of New States : Integrating new states into the system is not complicated. Developers can introduce new state classes without altering existing code, promoting adaptability and extensibility.

  • Adaptable State Transitions : State transitions can be flexibly managed within the context class. The context can establish rules for transitioning between states, enabling developers to tailor the behavior according to specific requirements.

  • Dynamic Behavior Adaptations : The State Pattern facilitates dynamic changes in behavior during runtime. The context can seamlessly switch between different states, allowing the system to adjust to evolving conditions or requirements.
By leveraging these benefits, the State Pattern proves to be a valuable tool for crafting systems with dynamic behavior and state transitions. Its capacity to encapsulate state-specific behavior in a modular manner makes it particularly advantageous for applications requiring flexible and maintainable state management.

When we should use State Pattern

When an object can have multiple internal states and it's behaviour varies as per its current states.

Implementation of State Design Pattern

State Design Pattern UML Diagram

First of all, we will declare a State interface having 'toggle' method to execute state specific logic. All concrete state classes must implement this interface.
public interface State {
   public void toggle(Switch sw);

OnState and OffState are concrete implemention of Switch interface representing the two possible state of a switch. Their toggle method contains state specific logic implementation.
public class OnState implements State { 
    public void toggle(Switch sw){
      // Write OnState specific code here
      System.out.println("Switch is in ON State.. Turning it OFF");
      sw.setState(new OffState());
public class OffState implements State {
    public void toggle(Switch sw){
      // Write OffState specific code here
      System.out.println("Switch is in OFF State.. Turning it ON");
      sw.setState(new OnState());

Switch is the Context object that can have two possible states ON and OFF. It compose a State object for delegation of any state specific behaviour.
public class Switch {
    private State state;
    public Switch(State state){
        this.state = state;
    public void setState(State state){
        this.state = state;
    public void toggleSwitch(){

StatePatternExample create instance of Switch class and initialize it's state with OnState. It changes the state of switch by call toggle method.
public class StatePatternExample {
    public static void main(String args[]){
        Switch sw = new Switch(new OnState());
        // Changing the state of switch
        sw.toggleSwitch();  // OFF
        sw.toggleSwitch();  // ON
        sw.toggleSwitch();  // OFF
        // Overriding the state of the swith to ON
        sw.setState(new OnState());
        sw.toggleSwitch(); // OFF
        sw.toggleSwitch();  //ON


Switch is in ON State.. Turning it OFF
Switch is in OFF State.. Turning it ON
Switch is in ON State.. Turning it OFF
Switch is in ON State.. Turning it OFF
Switch is in OFF State.. Turning it ON

Guidelines for Implementing State Design Pattern

  • Clearly articulate the methods representing state-specific behavior within the state interface. A lucid interface facilitates the implementation of concrete state classes.

  • Centralize the logic governing state transitions within the context class. This ensures centralized control over state transitions, enabling customization to meet specific requirements.

  • If multiple state classes share common behaviors, contemplate using an abstract class for the state instead of an interface. This abstract class can offer default implementations for shared behaviors.

  • Mitigate direct state checks in client code. Delegate state-specific behavior to the context, enabling clients to engage with the context without intricate knowledge of state transitions.

  • The State Design Pattern is especially potent for finite state machines. Identify distinct states and delineate state-specific behavior for each state in the machine.

  • Ensure thread safety in state transitions if the context is shared among multiple threads. Employ proper synchronization mechanisms to forestall race conditions.

  • Segregate the fundamental business logic of the context from the state-specific logic. This segregation fosters a well-organized and sustainable design, where alterations to business logic don't impact state management.

  • Furnish explicit documentation for each state class, elucidating the anticipated behavior in each state. This documentation aids developers in comprehending how to implement new state classes.

  • Contemplate utilizing dependency injection to supply states to the context. This approach allows greater flexibility in substituting various state implementations, facilitating system extension.

Related Topics
Facade Design Pattern
Adapter Design Pattern
Prototype Design Pattern
Abstract Factory Design Pattern
Builder Design Pattern
List of Design Patterns