Composition vs Inheritance — Favor Composition

from abc import ABC, abstractmethod


# ---------- Layer 1: Base class ----------
class Notification(ABC):
    @abstractmethod
    def send(self, recipient: str, message: str) -> None:
        pass


# ---------- Layer 2: Channel subclasses ----------
class EmailNotification(Notification):
    def send(self, recipient: str, message: str) -> None:
        print(f"  [EMAIL] To: {recipient} | {message}")


class SMSNotification(Notification):
    def send(self, recipient: str, message: str) -> None:
        print(f"  [SMS] To: {recipient} | {message}")


class PushNotification(Notification):
    def send(self, recipient: str, message: str) -> None:
        print(f"  [PUSH] To: {recipient} | {message}")


# ---------- Layer 3: Urgency × Channel (3 × 2 = 6 classes!) ----------
class UrgentEmailNotification(EmailNotification):
    def send(self, recipient: str, message: str) -> None:
        print("  [URGENT] Retrying up to 3 times...")
        for attempt in range(1, 4):
            print(f"    Attempt {attempt}:")
            super().send(recipient, f"[URGENT] {message}")


class UrgentSMSNotification(SMSNotification):
    def send(self, recipient: str, message: str) -> None:
        print("  [URGENT] Retrying up to 3 times...")
        for attempt in range(1, 4):
            print(f"    Attempt {attempt}:")
            super().send(recipient, f"[URGENT] {message}")


# Layer 4: Logging × Urgency × Channel = exponential explosion!
# UrgentLoggedEmailNotification? LoggedUrgentSMSNotification?
# What about RateLimitedUrgentLoggedPushNotification??
# This is unsustainable. STOP HERE.


print("--- Inheritance approach ---")
email = EmailNotification()
email.send("alice@example.com", "Welcome!")

urgent_email = UrgentEmailNotification()
urgent_email.send("alice@example.com", "Server is down!")

# Problem: To add logging, you'd need LoggedEmailNotification,
# LoggedSMSNotification, LoggedPushNotification,
# LoggedUrgentEmailNotification, LoggedUrgentSMSNotification...
# For 3 channels × 2 urgency × 2 logging × 2 rate-limit = 24 CLASSES

// Layer 1: Base class
abstract class Notification {
    abstract void send(String recipient, String message);
}

// Layer 2: Channel subclasses
class EmailNotification extends Notification {
    @Override
    void send(String recipient, String message) {
        System.out.println("  [EMAIL] To: " + recipient + " | " + message);
    }
}

class SMSNotification extends Notification {
    @Override
    void send(String recipient, String message) {
        System.out.println("  [SMS] To: " + recipient + " | " + message);
    }
}

// Layer 3: Urgency × Channel (already 6 classes!)
class UrgentEmailNotification extends EmailNotification {
    @Override
    void send(String recipient, String message) {
        System.out.println("  [URGENT] Retrying up to 3 times...");
        for (int attempt = 1; attempt <= 3; attempt++) {
            System.out.println("    Attempt " + attempt + ":");
            super.send(recipient, "[URGENT] " + message);
        }
    }
}

// Layer 4: Logging × Urgency × Channel = EXPLOSION
// LoggedUrgentEmailNotification extends UrgentEmailNotification?
// What if we need LoggedNormalEmailNotification too?
// This path leads to class hierarchy hell.

public class Main {
    public static void main(String[] args) {
        System.out.println("--- Inheritance approach ---");
        Notification email = new EmailNotification();
        email.send("alice@example.com", "Welcome!");

        Notification urgentEmail = new UrgentEmailNotification();
        urgentEmail.send("alice@example.com", "Server is down!");
    }
}

from abc import ABC, abstractmethod
from typing import List


# ---------- Step 1: Define the BEHAVIOR interfaces ----------
class DeliveryChannel(ABC):
    """HOW to deliver the notification (Email, SMS, Push)."""
    @abstractmethod
    def deliver(self, recipient: str, message: str) -> None:
        pass


class UrgencyPolicy(ABC):
    """HOW urgently to handle the notification."""
    @abstractmethod
    def apply(self, channel: DeliveryChannel, recipient: str, message: str) -> None:
        pass


# ---------- Step 2: Implement each behavior independently ----------
class EmailChannel(DeliveryChannel):
    def deliver(self, recipient: str, message: str) -> None:
        print(f"  [EMAIL] To: {recipient} | {message}")


class SMSChannel(DeliveryChannel):
    def deliver(self, recipient: str, message: str) -> None:
        print(f"  [SMS] To: {recipient} | {message}")


class PushChannel(DeliveryChannel):
    def deliver(self, recipient: str, message: str) -> None:
        print(f"  [PUSH] To: {recipient} | {message}")


class NormalUrgency(UrgencyPolicy):
    def apply(self, channel: DeliveryChannel, recipient: str, message: str) -> None:
        channel.deliver(recipient, message)


class UrgentRetry(UrgencyPolicy):
    def __init__(self, max_retries: int = 3):
        self._max_retries = max_retries

    def apply(self, channel: DeliveryChannel, recipient: str, message: str) -> None:
        print(f"  [URGENT] Retrying up to {self._max_retries} times...")
        for attempt in range(1, self._max_retries + 1):
            print(f"    Attempt {attempt}:")
            channel.deliver(recipient, f"[URGENT] {message}")


# ---------- Step 3: Compose behaviors in a single class ----------
class NotificationService:
    """
    Composes channel + urgency + optional middleware.
    No inheritance hierarchy — just pluggable components.
    """

    def __init__(self, channel: DeliveryChannel, urgency: UrgencyPolicy,
                 log_enabled: bool = False, rate_limit: int = 0):
        self._channel = channel        # HAS-A delivery channel
        self._urgency = urgency        # HAS-A urgency policy
        self._log_enabled = log_enabled
        self._rate_limit = rate_limit
        self._send_count = 0

    def send(self, recipient: str, message: str) -> None:
        if self._rate_limit > 0 and self._send_count >= self._rate_limit:
            print(f"  [RATE LIMITED] Blocked: {recipient}")
            return

        if self._log_enabled:
            print(f"  [LOG] Sending to {recipient}: {message}")

        self._urgency.apply(self._channel, recipient, message)
        self._send_count += 1


# ---------- Step 4: Mix and match ANY combination ----------
print("--- Composition approach ---")

# Normal email (same as before)
normal_email = NotificationService(EmailChannel(), NormalUrgency())
normal_email.send("alice@example.com", "Welcome!")

print()

# Urgent email with logging (no new class needed!)
urgent_logged_email = NotificationService(
    channel=EmailChannel(),
    urgency=UrgentRetry(max_retries=3),
    log_enabled=True
)
urgent_logged_email.send("alice@example.com", "Server is down!")

print()

# Rate-limited urgent SMS with logging (still no new class!)
rate_limited_sms = NotificationService(
    channel=SMSChannel(),
    urgency=UrgentRetry(max_retries=2),
    log_enabled=True,
    rate_limit=5
)
rate_limited_sms.send("+1234567890", "Alert!")

print()
print("--- Adding a new channel requires ONE class, not 8 ---")


class SlackChannel(DeliveryChannel):
    def deliver(self, recipient: str, message: str) -> None:
        print(f"  [SLACK] To #{recipient} | {message}")


# Instantly works with ALL existing urgency policies and features
urgent_slack = NotificationService(
    channel=SlackChannel(),
    urgency=UrgentRetry(),
    log_enabled=True
)
urgent_slack.send("engineering", "Deploy failed!")

// Step 1: Define behavior interfaces
interface DeliveryChannel {
    void deliver(String recipient, String message);
}

interface UrgencyPolicy {
    void apply(DeliveryChannel channel, String recipient, String message);
}

// Step 2: Implement each behavior independently
class EmailChannel implements DeliveryChannel {
    @Override
    public void deliver(String recipient, String message) {
        System.out.println("  [EMAIL] To: " + recipient + " | " + message);
    }
}

class SMSChannel implements DeliveryChannel {
    @Override
    public void deliver(String recipient, String message) {
        System.out.println("  [SMS] To: " + recipient + " | " + message);
    }
}

class NormalUrgency implements UrgencyPolicy {
    @Override
    public void apply(DeliveryChannel channel, String recipient, String message) {
        channel.deliver(recipient, message);
    }
}

class UrgentRetry implements UrgencyPolicy {
    private final int maxRetries;

    public UrgentRetry(int maxRetries) {
        this.maxRetries = maxRetries;
    }

    @Override
    public void apply(DeliveryChannel channel, String recipient, String message) {
        System.out.println("  [URGENT] Retrying up to " + maxRetries + " times...");
        for (int attempt = 1; attempt <= maxRetries; attempt++) {
            System.out.println("    Attempt " + attempt + ":");
            channel.deliver(recipient, "[URGENT] " + message);
        }
    }
}

// Step 3: Compose behaviors
class NotificationService {
    private final DeliveryChannel channel;
    private final UrgencyPolicy urgency;
    private final boolean logEnabled;
    private final int rateLimit;
    private int sendCount = 0;

    public NotificationService(DeliveryChannel channel, UrgencyPolicy urgency,
                                boolean logEnabled, int rateLimit) {
        this.channel = channel;
        this.urgency = urgency;
        this.logEnabled = logEnabled;
        this.rateLimit = rateLimit;
    }

    public void send(String recipient, String message) {
        if (rateLimit > 0 && sendCount >= rateLimit) {
            System.out.println("  [RATE LIMITED] Blocked: " + recipient);
            return;
        }
        if (logEnabled) {
            System.out.println("  [LOG] Sending to " + recipient + ": " + message);
        }
        urgency.apply(channel, recipient, message);
        sendCount++;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("--- Composition approach ---");

        // Normal email
        NotificationService normalEmail = new NotificationService(
            new EmailChannel(), new NormalUrgency(), false, 0);
        normalEmail.send("alice@example.com", "Welcome!");

        System.out.println();

        // Urgent email with logging — no new class!
        NotificationService urgentLoggedEmail = new NotificationService(
            new EmailChannel(), new UrgentRetry(3), true, 0);
        urgentLoggedEmail.send("alice@example.com", "Server is down!");

        System.out.println();

        // Adding Slack requires ONE class, works with everything
        DeliveryChannel slackChannel = (recipient, message) ->
            System.out.println("  [SLACK] To #" + recipient + " | " + message);

        NotificationService urgentSlack = new NotificationService(
            slackChannel, new UrgentRetry(2), true, 0);
        urgentSlack.send("engineering", "Deploy failed!");
    }
}