Suggest an edit

Improve this article

Refine the answer for “How does State simplify large conditional constructs (if-else/switch)?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

The **State** pattern simplifies large `if-else` and `switch` constructs,
by **spreading different behavior across separate classes**,
instead of keeping all the conditions and transitions inside one method.

---

### 1. **The Problem Without the Pattern**

When an object has several states, its behavior is often described through long conditional blocks:

```java
class Player {
    private String state = "IDLE";

public void handleInput(String input) {
        if (state.equals("IDLE")) {
            if (input.equals("PRESS")) state = "RUNNING";
        } else if (state.equals("RUNNING")) {
            if (input.equals("STOP")) state = "IDLE";
            else if (input.equals("ATTACK")) state = "ATTACKING";
        } else if (state.equals("ATTACKING")) {
            if (input.equals("STOP")) state = "IDLE";
        }
    }
}
```

The problem:

- The method grows to hundreds of lines.
- A new state means a new `if`.
- Any change means digging into existing code and risking breaking everything.

---

### 2. **How State Works**

The pattern moves each state into a **separate class**,
which holds only the logic relevant to that state.

```java
interface State {
    void handleInput(Player context, String input);
}

class IdleState implements State {
    public void handleInput(Player context, String input) {
        if (input.equals("PRESS")) context.setState(new RunningState());
    }
}

class RunningState implements State {
    public void handleInput(Player context, String input) {
        if (input.equals("STOP")) context.setState(new IdleState());
        if (input.equals("ATTACK")) context.setState(new AttackingState());
    }
}

class AttackingState implements State {
    public void handleInput(Player context, String input) {
        if (input.equals("STOP")) context.setState(new IdleState());
    }
}

class Player {
    private State state = new IdleState();
    public void setState(State s) { state = s; }
    public void handleInput(String input) { state.handleInput(this, input); }
}
```

Now, adding a new state simply means adding a **new class**,
not a new branch in an `if`.

---

### 3. **What Exactly Gets Simplified**

| Problem in `if-else` | Solution via State |
|---|---|
| One method manages all states | Each state encapsulates its own behavior |
| Hard to add new states | Adding a new class doesn't break the old ones |
| Code with nested `if` reads poorly | A flat structure, 1 class = 1 state |
| Changing logic breaks other branches | Isolation of changes: states are independent |
| Hard to test | Each state can be tested separately |

---

### 4. **Why This Works**

The pattern turns **state-dependent behavior**
into a **set of interchangeable objects** that the context simply switches between:

```java
context.setState(new AttackingState());
```

You no longer need to check "which state am I in right now",
the object *knows for itself* what to do in its own state.

---

### **Conclusion**

The **State** pattern removes bulky conditional blocks,
handing off responsibility for behavior to the state objects.

**Summary:**

> Instead of a hundred `if-else` statements inside one class,
> you get a dozen small classes, each knowing its own job.
> This makes the code **clean, extensible, and easy to read**.

Markdown · drag & drop images · ⌘B / ⌘I shortcuts466 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.