State pattern

The state pattern is a behavioral design pattern that enables an object to change its behavior when its internal state changes. It is one of the 23 classic patterns described in the 1994 book Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, collectively known as the Gang of Four.¹ The pattern defines a Context class that holds a reference to a State object representing the current state. Each concrete state class implements the behavior associated with that state, and the context delegates state-specific behavior to the current state object. When a state transition occurs, the context changes its state object, effectively altering its behavior without changing its class.

Implementing the state pattern involves defining an interface or abstract class for states, concrete state classes for each possible state, and a context class that maintains a reference to the current state. The context exposes methods that delegate to the current state, and state objects can trigger transitions by calling context methods to change the state. This approach eliminates large conditional statements (if-else or switch) that would otherwise be needed to handle state-specific behavior, making the code more modular and easier to extend.² It also adheres to the Open/Closed Principle, as new states can be added without modifying existing code. The pattern is particularly useful in scenarios where an object has many states and complex transitions, such as in workflow systems, parsers, and network protocols.

The state pattern is widely used in software development. Common examples include finite state machines in game development for character behavior, UI components that change behavior based on user interaction states (e.g., enabled/disabled), and network connection handling where the connection can be in states like connecting, connected, or disconnected.³ It is also used in compilers and interpreters to manage parsing states, and in workflow engines to model business processes. The pattern is language-agnostic and can be implemented in any object-oriented language, including Java, C++, and Python. In Java, for instance, the State interface and concrete state classes are often used in conjunction with the Context class to manage state transitions.

One lesser-known aspect is that the state pattern is closely related to the strategy pattern, but with a key difference: in the strategy pattern, the client typically chooses and sets the strategy, whereas in the state pattern, state transitions are often managed internally by the state objects themselves, making the pattern more autonomous.⁴ Another nuance is that the state pattern can be implemented using the table-driven approach, where state transitions are stored in a lookup table, which can be more efficient for systems with many states. Additionally, the pattern can be combined with the flyweight pattern to share state objects across multiple contexts, reducing memory usage. Some implementations use enums in languages like Java to represent states, but this can lead to less flexibility compared to using classes. The pattern is also known as the objects for states pattern in some literature.

Context

The class that maintains a reference to the current state object and delegates state-specific behavior to it.

State

An interface or abstract class that defines the methods for handling a particular state.

Concrete State

A class that implements the State interface and defines the behavior for a specific state.

Gang of Four

The four authors of the book 'Design Patterns: Elements of Reusable Object-Oriented Software'.