Java Tutorial: Behavioral Patterns 🎯

Welcome to CodeYourCraft's Java Tutorial on Behavioral Patterns! In this lesson, we'll dive into a fascinating world where objects communicate and collaborate, making our code more modular, flexible, and easier to maintain. 💡

What are Behavioral Patterns? 📝

Behavioral patterns are design patterns that identify common communication patterns between objects and realize these communication patterns. They help us design flexible and scalable applications by promoting loose coupling and code reusability.

Important Behavioral Patterns in Java 📝

Observer Pattern 🎯
- The Observer pattern defines a one-to-many dependency between objects, so that when one object changes its state, all its dependents are notified and updated automatically.
- Real-world example: Email newsletter subscription, where the subscribers (observers) receive updates (new posts) from the newsletter (subject).
Strategy Pattern 🎯
- The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This lets the algorithm be selected at runtime.
- Real-world example: Shipping calculator in an e-commerce site, where shipping cost is calculated using different strategies like weight-based, zone-based, or volumetric.
Command Pattern 🎯
- The Command pattern turns a request into a standalone object, thus letting you store, queue, or schedule requests. This separates the objects that issue a command from the objects that execute the command.
- Real-world example: DVR in a digital video recorder, where recording, playback, and pause are commands that can be scheduled or executed at any time.
Template Method Pattern 🎯
- The Template Method pattern defines the skeleton of an algorithm in a base class, allowing subclasses to redefine certain steps of the algorithm without changing the algorithm's structure.
- Real-world example: A bank account system, where the steps to withdraw or deposit money are defined in a base class, but the actual calculations (e.g., tax deductions) can be customized by subclasses.

Implementing Behavioral Patterns in Java 📝

We'll provide you with two complete, working examples of Strategy and Observer patterns to help you grasp these patterns better.

Strategy Pattern Example 📝

java

// Strategy Interface
interface ShippingStrategy {
    double calculateShippingCost(double weight, String zone);
}

// Concrete Strategy Implementations
class WeightBasedShipping implements ShippingStrategy {
    @Override
    public double calculateShippingCost(double weight, String zone) {
        double cost = weight * 10; // For simplicity, let's say cost is 10 times the weight
        return cost;
    }
}

class ZoneBasedShipping implements ShippingStrategy {
    @Override
    public double calculateShippingCost(double weight, String zone) {
        double cost = 5.0;
        if (zone.equals("zone1")) {
            cost += weight * 2.0;
        } else if (zone.equals("zone2")) {
            cost += weight * 3.0;
        } else {
            cost += weight * 4.0;
        }
        return cost;
    }
}

// Context Class
class ShoppingCart {
    private ShippingStrategy strategy;

    public void setShippingStrategy(ShippingStrategy strategy) {
        this.strategy = strategy;
    }

    public double calculateTotalCost(double weight, String zone) {
        double cost = strategy.calculateShippingCost(weight, zone);
        // Add item costs, taxes, and other charges here
        return cost;
    }
}

Observer Pattern Example 📝

java

// Subject Interface
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// Concrete Subject Implementation
class StockQuote implements Subject {
    private String symbol;
    private double price;
    private List<Observer> observers = new ArrayList<>();

    public StockQuote(String symbol) {
        this.symbol = symbol;
    }

    public void setPrice(double price) {
        this.price = price;
        notifyObservers();
    }

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(symbol, price);
        }
    }
}

// Observer Interface
interface Observer {
    void update(String symbol, double price);
}

// Concrete Observer Implementations
class StockBroker implements Observer {
    private String name;

    public StockBroker(String name) {
        this.name = name;
    }

    @Override
    public void update(String symbol, double price) {
        System.out.println(name + " received an update for " + symbol + " at $" + price);
    }
}

Java Tutorial: Behavioral Patterns 🎯

Java Tutorial: Behavioral Patterns 🎯

What are Behavioral Patterns? 📝

Important Behavioral Patterns in Java 📝

Implementing Behavioral Patterns in Java 📝

Strategy Pattern Example 📝

Observer Pattern Example 📝

Quiz 📝