State Pattern | Design Patterns
Tags: statepattern, pattern, designpatterns, java
Published: 2024-03-15 11:41:16

## Introduction

In the realm of software engineering, crafting robust, maintainable code is akin to an artist painting a masterpiece. It requires finesse, foresight, and a deep understanding of the tools at hand. Among the arsenal of design patterns lies one gem that stands out for its elegance and versatility: the [**State Pattern**](https://github.com/SajjadAli54/design-patterns/tree/main/src/part01/state).

## Unveiling the State Pattern


![Canvas and Tools](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/l89oetceoqnk2xwqdvd9.jpg)



Imagine you're tasked with building a canvas application capable of creating various shapes. At first glance, it seems straightforward—define tools like selection, brush, and eraser using enums, and let the Canvas class handle the rest. However, as the codebase grows, cracks begin to appear.

```java
public enum ToolType {
    SELECTION,
    BRUSH,
    ERASER
}

public class Canvas{
    private ToolType tool;

    public void mouseDown() {
        if(tool == ToolType.SELECTION)
            // Code for SELECTION Tool
        else if(tool == ToolType.BRUSH)
            // Code for Brush Tool
        else if(tool == ToolType.Eraser)
            // Code for Eraser Tool
    }

    public void mouseUp() {
        if(tool == ToolType.SELECTION)
            // Code for SELECTION Tool
        else if(tool == ToolType.BRUSH)
            // Code for Brush Tool
        else if(tool == ToolType.Eraser)
            // Code for Eraser Tool
    }

    public void setTool(ToolType tool){
        this.toot = tool;
    }
}
```

The initial implementation, although functional, lacks scalability and violates the **Open-Closed Principle**. Adding new tools necessitates modifying existing code, leading to a tangled mess of if-else statements. Enter the State Pattern—a beacon of clarity in the fog of complexity.

## The Pitfalls of Tradition


![Open CLosed Principle](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sogi63l2j368emquzqnw.png)



Before diving into the solution, let's dissect the shortcomings of the traditional approach. Maintenance becomes a Herculean task as the codebase sprawls with conditional statements. Each addition or modification sends ripples of change across the code, defying the **principle of encapsulation**.

## Embracing Abstraction

The State Pattern offers a lifeline amidst the chaos. By abstracting tool behavior into a common interface, we decouple the Canvas class from specific tool implementations. This not only streamlines the code but also fosters extensibility without sacrificing stability.

With a simple interface defining mouse actions, the Canvas class becomes a blank canvas awaiting the brush strokes of creativity. New tools can be seamlessly integrated by implementing the interface, keeping the codebase pristine and adaptable.

```java
public interface Tool {

    void mouseDown();

    void mouseUp();
}

public class Canvas {
    private Tool currentTool;

    public void mouseDown() {
        currentTool.mouseDown();
    }

    public void mouseUp() {
        currentTool.mouseUp();
    }

    public Tool getCurrentTool() {
        return currentTool;
    }

    public void setCurrentTool(Tool currentTool) {
        this.currentTool = currentTool;
    }

}

public class BrushTool implements Tool {

    @Override
    public void mouseDown() {
        System.out.println("Brush icon");
    }

    @Override
    public void mouseUp() {
        System.out.println("Draw a line");
    }

}

public class EraserTool implements Tool {

    @Override
    public void mouseDown() {
        System.out.println("Eraser icon");
    }

    @Override
    public void mouseUp() {
        System.out.println("Erase something");
    }

}


public class SelectionTool implements Tool {

    @Override
    public void mouseDown() {
        System.out.println("Selection icon");
    }

    @Override
    public void mouseUp() {
        System.out.println("Draw dashed rectangle");
    }

}
```

```java
public class Main {
    public static void main() {
        var canvas = new Canvas();
        canvas.setCurrentTool(new SelectionTool());
        canvas.mouseDown();
        canvas.mouseUp();

        canvas.setCurrentTool(new BrushTool());
        canvas.mouseDown();
        canvas.mouseUp();

        canvas.setCurrentTool(new EraserTool());
        canvas.mouseDown();
        canvas.mouseUp();
    }
}
```


## Harnessing the Power

Armed with this newfound clarity, crafting tools becomes a breeze. Each tool class encapsulates its behavior, adhering to the Single Responsibility Principle. Whether it's a brush, eraser, or selection tool, the State Pattern empowers developers to express their intentions concisely and elegantly.

## State Pattern in Practice


![Direction Service](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/snlri266kc03odgqrsrq.png)


Beyond the realm of canvas applications, the State Pattern finds its place in diverse domains. Consider a navigation app offering various modes of transportation—bicycling, driving, transit, and walking. By encapsulating each mode's behavior within a common interface, the application achieves flexibility without sacrificing cohesion.

```java
public interface Travel {
    Object getEta();
}


public class DirectionService {
    private Travel travel;

    public void setTravel(Travel travel) {
        this.travel = travel;
    }

    public Travel getTravel() {
        return travel;
    }

    public Object getEta() {
        return travel.getEta();
    }

}


public class Bicycling implements Travel {
    @Override
    public Object getEta() {
        System.out.println("Calculating ETA (bicycling)");
        return 2;
    }

}

public class Driving implements Travel {
    @Override
    public Object getEta() {
        System.out.println("Calculating ETA (driving)");
        return 1;
    }

}

public class Transit implements Travel {
    @Override
    public Object getEta() {
        System.out.println("Calculating ETA (transit)");
        return 3;
    }

}

public class Walking implements Travel {

    @Override
    public Object getEta() {
        System.out.println("Calculating ETA (walking)");
        return 4;
    }
}
```

## Conclusion: Elevating Design to Artistry

In conclusion, the State Pattern transcends mere code—it embodies a paradigm shift in design philosophy. By embracing abstraction and encapsulation, developers can sculpt intricate systems with ease, fostering resilience in the face of change. So, the next time you embark on a coding odyssey, remember the State Pattern—a brushstroke of genius in the tapestry of software design.


![Thanks](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3ze3y6vm1sntp7bb8mfe.jpg)