The **state [design pattern](https://www.educative.io/answers/design-patterns-in-java)** is used when a class needs to change its behavior based on its current state. For example, an object of the `Car` class has a horsepower of 150, and it increases to 200 after turning on turbo mode.

The default approach to implement this behavior is to create a member variable (`state`) and change its value whenever a certain condition is met, or a method is invoked. Afterward, when a state-specific action is to be performed, we can check the current state using if-else conditions and invoke the specific method. However, this will turn out to be a hassle in the long run because another state may be added in the future and, consequently, another if-else statement will have to be added.

The need to add if-else conditions is avoided when the state design pattern is implemented. There are two main classes that make up the state design pattern:

1. **Context:** The class whose state is changed.
2. **States:** The states that the context can acquire -- usually singletons.

# UML diagram

# Explanation

The *context* class contains a reference (or pointer)of type *state*, which is an [interface](https://www.educative.io/answers/what-is-a-java-interface). This way, [**polymorphism**](https://www.educative.io/answers/what-is-polymorphism) can be used to choose the method of the current state. The state can be changed by a method in either a derived state class or in the context class.

# Implementation

There are no interfaces in C++. Therefore​, an abstract base class, plus multiple inheritances, are used.

Similarly, in Python, an abstract base class is used instead of an interface. Since the `abstract` keyword does not exist in Python, abstract classes are declared using the `ABC` module.

#include <iostream>

using namespace std;

// State abstract class:
class State{
public:
    virtual void printState() = 0;
};

// 'Default' state (singleton):
class Default: public State{
private:
    static Default* instance;
    Default(){}
public:
    static Default* getInstance(){
        if(instance == nullptr)
            instance = new Default();
        
        return instance;
    }
    void printState(){
        cout << "\nCar is in normal mode. 150 BHP\n";
    }
};

Default* Default::instance = nullptr;

// 'Turbo' state (singleton):
class Turbo: public State{
private:
    static Turbo* instance;
    Turbo(){}
public:
    static Turbo* getInstance(){
        if(instance == nullptr)
            instance = new Turbo();
        
        return instance;
    }
    void printState(){
        cout << "\nTurbo mode turned on! 200 BHP\n";
    }
};

Turbo* Turbo::instance = nullptr;

// Context:
class Car{
    int id;
    string name;
    State* currentState;
public:
    Car(int i, string n){
        id = i;
        name = n;
        currentState = Default::getInstance();
    }
    void turboOn(){
        currentState = Turbo::getInstance();
    }
    void turboOff(){
        currentState = Default::getInstance();
    }
    void printInfo(){
        currentState->printState();
    }
    void printDetails(){
        cout << "ID: " << id << ", Name: " << name;
    }
};

int main(){
    // Testing:
    Car superCar(1, "Maserati");
    superCar.printDetails();
    superCar.printInfo();
    
    // Turn on turbo:
    superCar.turboOn();
    superCar.printInfo();
    
    // Turn off turbo:
    superCar.turboOff();
    superCar.printInfo();
    
    return 0;
}


// State interface:
interface State{
	public void printState();
}

// 'Default' state (singleton):
class Default implements State{
	static Default instance = null;
	private Default() {}
	public static Default getInstance() {
		if(instance == null)
			instance = new Default();
		
		return instance;
	}
	public void printState() {
		System.out.println("Car is in default mode. 150 BHP.");
	}
}

// 'Turbo' state (singleton):
class Turbo implements State{
	static Turbo instance = null;
	private Turbo() {}
	public static Turbo getInstance() {
		if(instance == null)
			instance = new Turbo();
		
		return instance;
	}
	public void printState() {
		System.out.println("Turbo mode turned on! 200 BHP.");
	}
}

// Context class:
class Car{
	private int id;
	private String name;
	private State currentState;
	Car(int i, String s){
		id = i;
		name = s;
		currentState = Default.getInstance();
	}
	public void turboOn() {
		currentState = Turbo.getInstance();
	}
	public void turboOff() {
		currentState = Default.getInstance();
	}
	public void printDetails() {
		System.out.println("ID: " + id + ", Name: " + name);
	}
	public void printInfo() {
		currentState.printState();
	}
}

class StatePattern {
	public static void main(String[] args) {
		Car exotic = new Car(1, "Maserati");
		exotic.printDetails();
		exotic.printInfo();
		
		// Turn on turbo mode:
		exotic.turboOn();
		exotic.printInfo();
		
		// Turn off turbo mode:
		exotic.turboOff();
		exotic.printInfo();
	}
}


Java

from abc import ABC, abstractmethod


# State abstract class:
class State(ABC):
    @abstractmethod
    def print_info(self):
        pass


# 'Default' state (singleton):
class Default(State):
    instance = None

    def __new__(cls):
        if cls.instance is None:
            cls.instance = object.__new__(cls)

        return cls.instance

    def print_info(self):
        print("Car is in normal mode: 150 BHP")


# 'Turbo' state (singleton):
class Turbo(State):
    instance = None

    def __new__(cls):
        if cls.instance is None:
            cls.instance = object.__new__(cls)

        return cls.instance

    def print_info(self):
        print("Car is in turbo mode: 200 BHP")


# Context class:
class Car:
    def __init__(self, i, name):
        self.id = i
        self.name = name
        self.current_state = Default()

    def print_details(self):
        print("ID: %s, Name: %s" % (self.id, self.name))

    def print_info(self):
        self.current_state.print_info()

    def turbo_on(self):
        self.current_state = Turbo()

    def turbo_off(self):
        self.current_state = Default()


# DRIVER PROGRAM:

superCar = Car(1, "Maserati")
superCar.print_details()
superCar.print_info()

# Turn on turbo mode:
superCar.turbo_on()
superCar.print_info()

# Go back to normal mode:
superCar.turbo_off()
superCar.print_info()


Python

What is the state design pattern?

The state design pattern allows a class to change behavior based on its current state, avoiding complex if-else conditions.