State Design Pattern: Dynamic Behavior Through Encapsulated States

🔄 State Design Pattern: Dynamic Behavior Through Encapsulated States

The State Design Pattern is a behavioral pattern that enables an object to alter its behavior when its internal state changes, appearing as if it has changed its class. This pattern is especially useful in systems that behave like finite-state machines, where transitions between states dictate different behaviors.

---

🎯 Intent and Motivation

Instead of using complex conditional logic (if, switch) to manage state-dependent behavior, the State pattern encapsulates each state in a separate class. This makes the code cleaner, more maintainable, and open to extension.

“State is a behavioral design pattern that lets an object alter its behavior when its internal state changes. It appears as if the object changed its class.” — Refactoring Guru

---

🧱 Key Components

Component	Description
Context	The object whose behavior changes based on its state
State Interface	Declares methods that concrete states must implement
Concrete States	Implement state-specific behavior and may trigger transitions

---

🧪 Example: Media Player

Imagine a media player that can be in one of three states: Playing, Paused, or Stopped.

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

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

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

class StoppedState implements State {
    public void pressPlay(MediaPlayer context) {
        System.out.println("Starting playback");
        context.setState(new PlayingState());
    }
}

// Context
class MediaPlayer {
    private State state;

    public MediaPlayer() {
        state = new StoppedState();
    }

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

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

Each state encapsulates its own behavior and knows what the next state should be. The MediaPlayer delegates behavior to the current state object.

---

✅ When to Use

• When an object’s behavior depends on its state
• When state transitions are frequent and complex
• When replacing conditionals with polymorphism improves clarity

---

❌ When Not to Use

• When state transitions are trivial or rare
• When the overhead of multiple classes outweighs the benefits
• When a simple enum or flag would suffice

---

🔍 Real-World Applications

• UI Components: Buttons that change behavior based on mode (e.g., edit, view)
• Workflow Engines: Document approval systems with states like Draft, Submitted, Approved
• Game Development: Character states like Idle, Walking, Jumping, Attacking

---

🔄 Comparison with Strategy Pattern

Feature	State Pattern	Strategy Pattern
Intent	Change behavior based on internal state	Choose algorithm based on external input
Transition	States transition internally	Strategies are chosen externally
Example	Media player switching states	Sorting algorithms selected at runtime

---

🧠 Summary

The State Design Pattern offers a robust way to model dynamic behavior in systems where objects change based on internal conditions. By encapsulating each state as a class, it promotes clean separation of concerns, extensibility, and runtime flexibility.