A simple example of the State Design Pattern

Here's the formal definition of the state design pattern :

The State Pattern allows an object to alter its behavior when its internal state changes. The object will appear to change its class.

The UML diagram :


If you don't understand this obscure definition nor the UML diagram, don't worry. I made a simple example for you. The state pattern is just a clean way for an object to partially change its type at runtime.

Let's take a pizza store. A pizza store is cooking pizza, baking it and delivering it to their clients. Our pizza is the context object with a state.

So here's how you do that the old fashion way :


Pizza.class

public class Pizza {
 
 public final static int COOKED = 0;
 public final static int BAKED = 1;
 public final static int DELIVERED = 2;
 
 private String name;
 
 int state = COOKED;
 
 public String getName() {
  return name;
 }
 
 public void setName(String name) {
  this.name = name;
 }
 
 public int getState() {
  return state;
 }
 
 public void setState(int state) {
  this.state = state;
 }
 
 public void bake() throws Exception {
  
  if(state == COOKED) {
   System.out.print("Baking the pizza...");
   state = BAKED;
  }
  else if(state == BAKED) {
   throw new Exception("Can't bake a pizza already baked");
  }
  else if(state == DELIVERED) {
   throw new Exception("Can't bake a pizza already delivered");
  }
 } 
 
 public void deliver() throws Exception {
  
  if(state == COOKED) {
   throw new Exception("Can't deliver a pizza not baked yet");
  }
  else if(state == BAKED) {
   System.out.print("Delivering the pizza...");
   state = DELIVERED;
  }
  else if(state == DELIVERED) {
   throw new Exception("Can't deliver a pizza already delivered");
  }
 }
}

The problem with this implementation is that everything is going messy when you have a lot of state. Moreover, the add of a new state is not that simple.

Let's see the re-factored example using the State Design Pattern.

Firstable, we have to write the state interface. This interface will describe the different transitions.


PizzaState.class

public interface PizzaState {

 void bake() throws Exception;

 void deliver() throws Exception;
}

Then, we refactor our Pizza object with our new state interface.


Pizza.class

public class Pizza {
 
 PizzaState cookedState;
 PizzaState bakedState;
 PizzaState deliveredState;
 
 private String name;
 
 //State initialization
 private PizzaState state = cookedState;
 
 public Pizza() {
  cookedState = new CookedPizzaState(this);
  bakedState = new BakedPizzaState(this);
  deliveredState = new DeliveredPizzaState(this);
 }
 
 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public PizzaState getState() {
  return state;
 }

 public void setState(PizzaState state) {
  this.state = state;
 }
 
 public void bake() throws Exception {
  this.state.bake();
 } 
 
 public void deliver() throws Exception {
  this.state.deliver();
 }

 public PizzaState getCookedState() {
  return createdState;
 }

 public PizzaState getBakedState() {
  return bakedState;
 }

 public PizzaState getDeliveredState() {
  return deliveredState;
 }
}

And last but not least, we write the state implementations.


CookedPizzaState.class

public class CookedPizzaState implements PizzaState {
 
 private Pizza pizza;
 
 public CookedPizzaState(Pizza pizza) {
  this.pizza = pizza;
 }

 public void bake() throws Exception {
  System.out.print("Baking the pizza...");
  pizza.setState(pizza.getBakedState());
 }

 public void deliver() throws Exception {
  throw new Exception("Can't deliver a pizza not baked yet");
 }

}

You still have to write BakedPizzaState.class and the DeliveredPizzaState.class.

The state design pattern is one of those you need to know and master. It can help you in complex situations.