Strategy Pattern

Hicham — Mon, 11 Aug 2025 13:29:59 +0000

Strategy design pattern is one of the behavioral design pattern. Strategy pattern is used when we have multiple algorithm for a specific task and client decides the actual implementation to be used at runtime

// Strategy interface
interface PaymentStrategy {
    void pay(double amount);
}

// Concrete strategies

class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " using Credit Card.");
    }
}

class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " using PayPal.");
    }
}

class CashPayment implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " in cash.");
    }
}

// Context

class Checkout {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void processOrder(double amount) {
        if (paymentStrategy == null) {
            throw new IllegalStateException("Payment strategy not set");
        }
        paymentStrategy.pay(amount);
    }
}

// Client

public class Main {
    public static void main(String[] args) {
        Checkout checkout = new Checkout();

        checkout.setPaymentStrategy(new CreditCardPayment());
        checkout.processOrder(25.50);

        checkout.setPaymentStrategy(new PayPalPayment());
        checkout.processOrder(13.75);

        checkout.setPaymentStrategy(new CashPayment());
        checkout.processOrder(7.00);
    }
}

Output will be :

Paid $25.5 using Credit Card.
Paid $13.75 using PayPal.
Paid $7.0 in cash.

Factory Method vs Abstract Factory — What's the Difference?

Hicham — Sun, 10 Aug 2025 17:20:36 +0000

Factory Method and Abstract Factory are two common ways to handle object creation. They sound similar, but their purpose and structure are a bit different.

Factory Method Pattern

Idea: A single factory class decides which object to create, often based on input like a String or enum.

Pros:

Simple and centralized.

Good for small product sets.

Cons:

Adding new products requires modifying the factory (more if/else).

Coffee Shop Example:

CoffeeFactory has makeCoffee(String type).

You pass "latte" or "espresso", and it returns the right coffee object.

// Coffee interface
public interface Coffee {
void prepare();
}

// Concrete coffee types
public class Espresso implements Coffee {
@override
public void prepare() {
System.out.println("Grinding beans, brewing strong espresso...");
}
}

public class Latte implements Coffee {
@override
public void prepare() {
System.out.println("Brewing coffee, adding steamed milk...");
}
}

// Factory Method
public class CoffeeFactory {
public Coffee makeCoffee(String type) {
if (type.equalsIgnoreCase("espresso")) {
return new Espresso();
} else if (type.equalsIgnoreCase("latte")) {
return new Latte();
} else {
throw new IllegalArgumentException("Unknown coffee type: " + type);
}
}
}

// Client
public class Main {
public static void main(String[] args) {
CoffeeFactory factory = new CoffeeFactory();

    Coffee coffee1 = factory.makeCoffee("espresso");
    coffee1.prepare();

    Coffee coffee2 = factory.makeCoffee("latte");
    coffee2.prepare();
}

}

Abstract Factory Pattern

Idea:
Instead of one factory with conditionals, you have an abstract factory interface with multiple concrete factories, each producing one specific type or a family of related products.

The client chooses which factory to use — no if/else needed inside the factory.

Pros:

No big conditional logic.

Easy to add new product types by creating a new factory.

Supports creating families of related products (e.g., coffee + tea sets).

Cons:

More classes to maintain.

May be overkill for small projects.

Coffee Shop Example:

EspressoFactory always makes Espresso.

LatteFactory always makes Latte.

// Coffee interface
public interface Coffee {
void prepare();
}

// Concrete coffee types
public class Espresso implements Coffee {
@override
public void prepare() {
System.out.println("Grinding beans, brewing strong espresso...");
}
}

public class Latte implements Coffee {
@override
public void prepare() {
System.out.println("Brewing coffee, adding steamed milk...");
}
}

// Abstract factory
public abstract class CoffeeFactory {
public abstract Coffee createCoffee();
}

// Concrete factories
public class EspressoFactory extends CoffeeFactory {
@override
public Coffee createCoffee() {
return new Espresso();
}
}

public class LatteFactory extends CoffeeFactory {
@override
public Coffee createCoffee() {
return new Latte();
}
}

// Client
public class Main {
public static void main(String[] args) {
CoffeeFactory espressoFactory = new EspressoFactory();
Coffee espresso = espressoFactory.createCoffee();
espresso.prepare();

    CoffeeFactory latteFactory = new LatteFactory();
    Coffee latte = latteFactory.createCoffee();
    latte.prepare();
}

}

DEV Community: Hicham

Strategy Pattern

Factory Method vs Abstract Factory — What's the Difference?