Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Difference Between State and Strategy Design Pattern in Java
Being a Java developer, one might have encountered some design patterns that help us in structuring our code and make it more reusable and maintainable. Two of these design patterns are the State pattern and the Strategy pattern. The use case of these design patterns is almost the same. However, they are different from each other in many ways. In this article, we are going to explore the differences between state and strategy design patterns in Java.
State vs Strategy Design Pattern
State Design Pattern
The State pattern is a behavioral design pattern that allows an object to change its behavior when its internal state changes. The State pattern encapsulates the state-specific behavior in separate classes and distributes the requests to the appropriate state object. This way, the context class does not have to handle complex conditional logic and can easily switch between different states at runtime.
To better understand this pattern, let's take an example of a smartphone and assume its three states as ON, OFF and LOCKED. Depending on the state, we can perform different actions, such as smarphones allowing users to adjust the volume in LOCKED state but to use its all functionality, we need to put it in ON state. The State pattern allows us to define each state as a separate class that implements a common interface to handle the state-specific logic.
Advantages of using State design pattern
It allows us to avoid complex conditional logic like if-else or switch-case in our code.
We can encapsulate the state-specific behavior in separate classes.
It is easy to integrate additional behaviors when needed.
Strategy Design Pattern
The Strategy pattern is also a behavioral design pattern that allows an object to change its behavior by switching between different algorithms or strategies. The Strategy pattern defines a group of interchangeable algorithms that implement a common interface and encapsulates them in separate classes. The context class holds a reference to the current strategy object and distributes the requests to it.
Let's take an example of a payment gateway to get a clear picture of this pattern. A payment gateway can have different mechanisms to accept payments from users such as Paytm and Gpay. Depending on the user's choice, a particular payment mechanism gets selected for further operation. Note that both payment mechanisms are independent of each other and also interchangeable with each other. We need to define each strategy as a separate class that implements a common interface and handles the payment logic.
Advantages of using Strategy design pattern
The algorithms or strategies used are independent of each other.
We can integrate additional strategies without affecting the application.
It allows us to switch between multiple algorithms or strategies at runtime.
Difference between State and Strategy Design Pattern
From the above discussion, we can conclude the following differences between State pattern and Strategy pattern:
| State pattern | Strategy pattern |
|---|---|
| It is a dependent design pattern that allows us to easily switch from one state to another. | It is an independent design pattern that means objects are not aware of each other. |
| In it, we perform different operations based on different states. | In it, we create distinct implementations to accomplish a single operation. |
| All states are linked and dependent to each other creating a pre-defined transition of states. | The users are aware of the strategy type and can choose based on their convenience. |
| State pattern encapsulates various behavior as state object. | Strategy pattern encapsulates various behavior as algorithms or strategies. |
| Here change is done implicitly by the state object. | Here change is done by the user explicitly. |
Conclusion
In this article, we have understood the distinction between two of the widely used design patterns named State and Strategy patterns. Both of the design patterns follow Open Closed design principle and encapsulate behaviors. They change the behavior of an object by delegating the work to other helper objects. One important point must be noted that the state design pattern is built on top of the strategy pattern.
171 Views
