The State Design Pattern: Why State Management Doesn't Have to be a Mess

In this article, we will discuss what the State pattern is and how it can be used in Java to build a vending machine.

As a developer, you've probably encountered situations where you need to manage the state of your application. You might have even found yourself tangled in a mess of if-else statements and switch cases. Fear not! The State Design Pattern can help simplify your code and make state management a breeze.

So what is the State Design Pattern anyway? It is a behavioral design pattern that allows objects to change their behavior based on their internal state, without having to change the object's class. This means that a single object can behave differently depending on its state, without needing to change the code everywhere it's used.

To understand the State Design Pattern, let's dive into the three main components: the Context, the State, and the Concrete States.

1. The Context is the object that has a state and whose behavior changes as its state changes. In Java, this might look something like this:

public class Context {
    private State state;

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

    public void doSomething() {
        state.handle();
    }
}        

2. The State is a nterface or abstract class that defines the methods that the Context uses to interact with the state. In Java, this might look like this:

public interface State {
    void handle();
}        

3. Finally, the Concrete States are the actual states that the Context can be in, and they implement the methods defined by the State. In Java, this might look something like this:

public class ConcreteState1 implements State {
    @Override
    public void handle() {
        System.out.println("Handling ConcreteState1");
    }
}

public class ConcreteState2 implements State {
    @Override
    public void handle() {
        System.out.println("Handling ConcreteState2");
    }
}        

To use the State Design Pattern, you would typically start by defining the Context and State classes. The Context class should have a reference to a State object, and should call the appropriate methods on that object based on its current state.

Next, you would define the Concrete States that the Context can be in. These states should implement the methods defined by the State interface, and should include any state-specific behavior that is required.

Finally, you would use the Context and Concrete States to manage state transitions. For example, when the user clicks a button, you would change the Context's state to the appropriate Concrete State. This would cause the Context to behave differently, based on its new state.

Here's an example that shows how this might work in practice:

public static void main(String[] args) {
    Context context = new Context();

    ConcreteState1 state1 = new ConcreteState1();
    ConcreteState2 state2 = new ConcreteState2();

    context.setState(state1);
    context.doSomething();

    context.setState(state2);
    context.doSomething();
}        

In this example, we create a new Context object and two Concrete States: ConcreteState1 and ConcreteState2. We set the Context's initial state to ConcreteState1, and then call the doSomething() method on the Context. This causes the Context to call the handle() method on the ConcreteState1 object. We then change the Context's state to ConcreteState2, and call doSomething() again. This time, the Context calls the handle() method on the ConcreteState2 object.

As you can see, using the State Design Pattern can help simplify your code and make state management much easier. By separating state-specific behavior from the main class, and providing a flexible framework for managing state transitions, you can reduce errors and build more modular, scalable software.

Example: Using the State Design Pattern to Build a Vending Machine in Java

First, let's define the context of the vending machine.

public class VendingMachine {
    private State state;

    public VendingMachine() {
        state = new WaitingForMoneyState();
    }

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

    public void insertMoney(int amount) {
        state.insertMoney(this, amount);
    }

    public void selectProduct(String product) {
        state.selectProduct(this, product);
    }

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

In the above code, we define the VendingMachine class with a state variable and three methods that correspond to the actions the user can take: insertMoney, selectProduct, and dispenseProduct. These methods delegate the behavior to the current state object.

Now, let's define the State interface and the concrete state classes.

public interface State {
    void insertMoney(VendingMachine vendingMachine, int amount);
    void selectProduct(VendingMachine vendingMachine, String product);
    void dispenseProduct(VendingMachine vendingMachine);
}

public class WaitingForMoneyState implements State {
    @Override
    public void insertMoney(VendingMachine vendingMachine, int amount) {
        vendingMachine.setState(new WaitingForSelectionState(amount));
    }

    @Override
    public void selectProduct(VendingMachine vendingMachine, String product) {
        System.out.println("Please insert money first");
    }

    @Override
    public void dispenseProduct(VendingMachine vendingMachine) {
        System.out.println("Please insert money and select a product first");
    }
}

public class WaitingForSelectionState implements State {
    private int amount;

    public WaitingForSelectionState(int amount) {
        this.amount = amount;
    }

    @Override
    public void insertMoney(VendingMachine vendingMachine, int amount) {
        this.amount += amount;
    }

    @Override
    public void selectProduct(VendingMachine vendingMachine, String product) {
        if (product.equals("chips") && amount >= 50) {
            System.out.println("Dispensing chips");
            vendingMachine.setState(new WaitingForMoneyState());
        } else if (product.equals("candy") && amount >= 25) {
            System.out.println("Dispensing candy");
            vendingMachine.setState(new WaitingForMoneyState());
        } else {
            System.out.println("Insufficient funds for " + product);
        }
    }

    @Override
    public void dispenseProduct(VendingMachine vendingMachine) {
        System.out.println("Please select a product first");
    }
}        

In the above code, we define the State interface with three methods: insertMoney, selectProduct, and dispenseProduct. We then define two concrete state classes: WaitingForMoneyState and WaitingForSelectionState.

The WaitingForMoneyState class handles the case where the user has not yet inserted any money. If the user tries to select a product or dispense a product without first inserting money, an error message is displayed.

The WaitingForSelectionState class handles the case where the user has inserted money and is waiting to select a product. If the user selects a product that they can afford, the product is dispensed, and the state is changed back to WaitingForMoneyState. If the user selects a product they cannot afford, an error message is displayed.

Finally, let's see how we can use our VendingMachine.

public class Main {
    public static void main(String[] args) {
        VendingMachine vendingMachine = new VendingMachine();

        vendingMachine.selectProduct("chips");
        vendingMachine.insertMoney(25);
        vendingMachine.selectProduct("chips");
        vendingMachine.insertMoney(25);
        vendingMachine.selectProduct("chips");
        vendingMachine.insertMoney(10);
        vendingMachine.selectProduct("candy");
        vendingMachine.insertMoney(25);
        vendingMachine.dispenseProduct();
    }        

In the above code, we create a VendingMachine object and test it by selecting chips three times, inserting 60 cents, selecting chips again, inserting 10 cents, selecting candy, and finally dispensing the product.

In conclusion, the State Design Pattern is a powerful tool that can help you manage state transitions in your code. By using the Context, State, and Concrete States, you can make your code more flexible, easier to read and understand, and more maintainable.

And that's it! I hope this article has given you a good understanding of the State pattern and how it can be used to build a vending machine in Java.