The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

State

Next ►
►

Introduction to the State Pattern

The State pattern is a behavioral design pattern that allows an object to change its behavior when its internal state changes. This pattern is particularly useful when an object must change its behavior based on its state, making the object appear to change its class.

Key Concepts

  • State: Represents a particular state of the context.
  • Context: Maintains an instance of a ConcreteState subclass that defines the current state.
  • ConcreteState: Implements behavior associated with a state of the Context.

Structure

The State pattern involves the following components:

  1. Context: The class that maintains an instance of a ConcreteState subclass.
  2. State: An interface or abstract class that defines the behavior associated with a state.
  3. ConcreteState: Classes that implement the State interface and define specific behaviors for each state.

UML Diagram

+-----------------+           +-----------------+
|     Context     |<----------|     State       |
+-----------------+           +-----------------+
| - state: State  |           | + handle(): void|
+-----------------+           +-----------------+
| + request(): void|          |                 |
+-----------------+           +-----------------+
       |                            ^
       |                            |
       v                            |
+-----------------+           +-----------------+
| ConcreteStateA  |           | ConcreteStateB  |
+-----------------+           +-----------------+
| + handle(): void|           | + handle(): void|
+-----------------+           +-----------------+

Example

Let's consider a simple example where we have a Context class representing a traffic light system. The traffic light can be in one of three states: Red, Yellow, or Green.

Step-by-Step Implementation

  1. Define the State Interface
public interface State {
    void handle(TrafficLightContext context);
}
  1. Implement Concrete States
public class RedState implements State {
    @Override
    public void handle(TrafficLightContext context) {
        System.out.println("Traffic light is Red. Stop!");
        context.setState(new GreenState());
    }
}

public class YellowState implements State {
    @Override
    public void handle(TrafficLightContext context) {
        System.out.println("Traffic light is Yellow. Get ready to stop.");
        context.setState(new RedState());
    }
}

public class GreenState implements State {
    @Override
    public void handle(TrafficLightContext context) {
        System.out.println("Traffic light is Green. Go!");
        context.setState(new YellowState());
    }
}
  1. Create the Context Class
public class TrafficLightContext {
    private State state;

    public TrafficLightContext() {
        state = new RedState(); // Initial state
    }

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

    public void request() {
        state.handle(this);
    }
}
  1. Test the State Pattern
public class StatePatternDemo {
    public static void main(String[] args) {
        TrafficLightContext context = new TrafficLightContext();

        for (int i = 0; i < 6; i++) {
            context.request();
        }
    }
}

Explanation

  • The State interface defines a method handle that takes a TrafficLightContext object.
  • RedState, YellowState, and GreenState are concrete implementations of the State interface.
  • The TrafficLightContext class maintains a reference to the current state and delegates the state-specific behavior to the current state object.
  • In the StatePatternDemo class, we create a TrafficLightContext object and repeatedly call its request method to see the state transitions.

Practical Exercise

Exercise

Create a vending machine simulation using the State pattern. The vending machine can be in one of the following states: Idle, HasMoney, Dispensing, and OutOfStock. Implement the state transitions and behaviors for each state.

Solution

  1. Define the State Interface
public interface VendingMachineState {
    void insertMoney(VendingMachineContext context);
    void dispenseProduct(VendingMachineContext context);
}
  1. Implement Concrete States
public class IdleState implements VendingMachineState {
    @Override
    public void insertMoney(VendingMachineContext context) {
        System.out.println("Money inserted. Ready to dispense.");
        context.setState(new HasMoneyState());
    }

    @Override
    public void dispenseProduct(VendingMachineContext context) {
        System.out.println("Insert money first.");
    }
}

public class HasMoneyState implements VendingMachineState {
    @Override
    public void insertMoney(VendingMachineContext context) {
        System.out.println("Money already inserted.");
    }

    @Override
    public void dispenseProduct(VendingMachineContext context) {
        System.out.println("Dispensing product...");
        context.setState(new IdleState());
    }
}

public class OutOfStockState implements VendingMachineState {
    @Override
    public void insertMoney(VendingMachineContext context) {
        System.out.println("Out of stock. Cannot accept money.");
    }

    @Override
    public void dispenseProduct(VendingMachineContext context) {
        System.out.println("Out of stock.");
    }
}
  1. Create the Context Class
public class VendingMachineContext {
    private VendingMachineState state;

    public VendingMachineContext() {
        state = new IdleState(); // Initial state
    }

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

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

    public void dispenseProduct() {
        state.dispenseProduct(this);
    }
}
  1. Test the Vending Machine
public class VendingMachineDemo {
    public static void main(String[] args) {
        VendingMachineContext vendingMachine = new VendingMachineContext();

        vendingMachine.insertMoney();
        vendingMachine.dispenseProduct();
        vendingMachine.insertMoney();
        vendingMachine.insertMoney();
        vendingMachine.dispenseProduct();
    }
}

Explanation

  • The VendingMachineState interface defines methods for inserting money and dispensing a product.
  • IdleState, HasMoneyState, and OutOfStockState are concrete implementations of the VendingMachineState interface.
  • The VendingMachineContext class maintains a reference to the current state and delegates state-specific behavior to the current state object.
  • In the VendingMachineDemo class, we create a VendingMachineContext object and simulate inserting money and dispensing products.

Common Mistakes and Tips

  • Forgetting to Change State: Ensure that each state transition updates the context's state.
  • State Explosion: Avoid creating too many states; combine similar behaviors if possible.
  • Context Awareness: States should be aware of the context to transition to the next state.

Conclusion

The State pattern is a powerful tool for managing state-dependent behavior in an object-oriented way. By encapsulating state-specific behavior and delegating state transitions, the State pattern promotes cleaner and more maintainable code. Understanding and applying this pattern can significantly improve the design and flexibility of your software systems.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved