state design pattern java example

state design pattern java example

I'm happy to respond in English!

Design Patterns in Java: Observer Pattern Example

The Observer design pattern is a behavioral pattern that defines a one-to-many dependency between objects so that when one object changes its state, all its dependents are notified and updated automatically.

Problem Statement

Suppose you have an online shopping website where products are categorized into different departments (e.g., Electronics, Fashion, etc.). Each department has multiple product items. When the price of a specific product item is updated, it's essential to notify all relevant departments that offer this product so they can update their inventory prices accordingly.

Java Implementation

Here's an example implementation of the Observer pattern in Java:

// Product interface
public interface Product {
void setPrice(double newPrice);
}
// Concrete product: ElectronicsProduct
public class ElectronicsProduct implements Product {
private double price;
public void setPrice(double newPrice) {
price = newPrice;
System.out.println("Electronics product price updated to " + newPrice);
}
}
// Department interface
public interface Department {
void update(Product product);
}
// Concrete department: ElectronicsDepartment
public class ElectronicsDepartment implements Department {
@Override
public void update(Product product) {
System.out.println("Electronics department received an update about " + product.getClass().getSimpleName() + " price change.");
}
}
// Subject (ProductManager)
public class ProductManager {
private List observers;
public ProductManager() {
observers = new ArrayList<>();
}
public void registerObserver(Observer observer) {
observers.add(observer);
}
public void notifyObservers(Product product) {
for (Observer observer : observers) {
observer.update(product);
}
}
}
// Observer interface
public interface Observer {
void update(Product product);
}
// Concrete observer: ProductItemObserver
public class ProductItemObserver implements Observer {
@Override
public void update(Product product) {
System.out.println("Product item price changed to " + ((Product) product).getPrice());
}
}

Usage Example

Now let's create a scenario where we have an electronics product, and when its price is updated, it notifies all the registered departments:

public class Main {
public static void main(String[] args) {
// Create products and departments
Product electronicsProduct = new ElectronicsProduct();
Department electronicsDepartment = new ElectronicsDepartment();
// Register observer
ProductManager productManager = new ProductManager();
productManager.registerObserver(electronicsDepartment);
// Update price
electronicsProduct.setPrice(199.99);
// Output:
// Electronics department received an update about ElectronicsProduct price change.
}
}

Conclusion

In this example, we've demonstrated the Observer pattern in Java by creating a ProductManager that maintains a list of observers (departments). When a product's price is updated, it notifies all registered departments, which can then react accordingly. This design pattern allows for loose coupling between objects, making it easier to manage complex relationships and scalability.

I hope this helps! Let me know if you have any further questions or need more examples.

What are the 4 states of thread in Java?

I'm happy to help!

In Java, a thread is a single flow of program execution that can run concurrently with other threads. There are four main states of a thread in Java:

Additional notes:

Hope this helps! Let me know if you have any further questions