Design Patterns in Java

// Simple Factory: static method that creates objects
public class NotificationFactory {

    public static Notification create(String type) {
        return switch (type) {
            case "email" -> new EmailNotification();
            case "sms" -> new SmsNotification();
            case "push" -> new PushNotification();
            default -> throw new IllegalArgumentException("Unknown: " + type);
        };
    }
}

// Usage
Notification notif = NotificationFactory.create("sms");
notif.send("Hello!");

// Real-world Java examples:
List<String> list = List.of("a", "b");     // Factory method
Optional<String> opt = Optional.of("x");   // Factory method
LocalDate date = LocalDate.now();          // Factory method
ExecutorService exec = Executors.newFixedThreadPool(4);  // Factory

// You need this interface
public interface PaymentProcessor {
    PaymentResult charge(Money amount, Card card);
}

// But you have this legacy/third-party class
public class LegacyPaymentGateway {
    public int processPayment(double amountCents, String cardNumber,
                              String expiry, String cvv) {
        // Returns status code
    }
}

// Adapter makes legacy class work with new interface
public class LegacyPaymentAdapter implements PaymentProcessor {
    private final LegacyPaymentGateway gateway;

    public LegacyPaymentAdapter(LegacyPaymentGateway gateway) {
        this.gateway = gateway;
    }

    @Override
    public PaymentResult charge(Money amount, Card card) {
        // Translate between interfaces
        double cents = amount.toCents();
        int statusCode = gateway.processPayment(
            cents,
            card.getNumber(),
            card.getExpiry(),
            card.getCvv()
        );

        // Translate result
        return switch (statusCode) {
            case 0 -> PaymentResult.success();
            case 1 -> PaymentResult.declined();
            default -> PaymentResult.error("Unknown status: " + statusCode);
        };
    }
}

// Usage - your code uses the clean interface
PaymentProcessor processor = new LegacyPaymentAdapter(legacyGateway);
PaymentResult result = processor.charge(money, card);

// Interface
public interface Image {
    void display();
}

// Real implementation (expensive to create)
public class HighResImage implements Image {
    private final byte[] data;

    public HighResImage(String path) {
        this.data = loadFromDisk(path);  // Expensive!
    }

    public void display() {
        renderToScreen(data);
    }
}

// LAZY LOADING PROXY
public class LazyImageProxy implements Image {
    private final String path;
    private HighResImage realImage;  // Loaded on demand

    public LazyImageProxy(String path) {
        this.path = path;  // Just store path, don't load yet
    }

    public void display() {
        if (realImage == null) {
            realImage = new HighResImage(path);  // Load now
        }
        realImage.display();
    }
}

// CACHING PROXY
public class CachingUserService implements UserService {
    private final UserService delegate;
    private final Cache<String, User> cache;

    @Override
    public User getUser(String id) {
        return cache.computeIfAbsent(id, delegate::getUser);
    }
}

// LOGGING PROXY (via Java dynamic proxy)
UserService loggingProxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),
    new Class[]{UserService.class},
    (proxy, method, args) -> {
        log.info("Calling: {}", method.getName());
        Object result = method.invoke(realService, args);
        log.info("Returned: {}", result);
        return result;
    }
);

// Spring uses proxies extensively for:
// - @Transactional (wrap method in transaction)
// - @Cacheable (cache method results)
// - @Async (run method in separate thread)

// Observer interface
public interface OrderEventListener {
    void onOrderPlaced(Order order);
    void onOrderShipped(Order order);
    void onOrderCancelled(Order order);
}

// Subject (Observable)
public class OrderService {
    private final List<OrderEventListener> listeners = new CopyOnWriteArrayList<>();

    public void addListener(OrderEventListener listener) {
        listeners.add(listener);
    }

    public void removeListener(OrderEventListener listener) {
        listeners.remove(listener);
    }

    public void placeOrder(Order order) {
        // Business logic
        saveOrder(order);

        // Notify all observers
        listeners.forEach(l -> l.onOrderPlaced(order));
    }
}

// Concrete observers
public class EmailNotifier implements OrderEventListener {
    public void onOrderPlaced(Order order) {
        sendEmail(order.getCustomer(), "Order confirmed!");
    }
    // ... other methods
}

public class InventoryUpdater implements OrderEventListener {
    public void onOrderPlaced(Order order) {
        decrementStock(order.getItems());
    }
    // ... other methods
}

// Usage
OrderService orderService = new OrderService();
orderService.addListener(new EmailNotifier());
orderService.addListener(new InventoryUpdater());
orderService.addListener(new AnalyticsTracker());

orderService.placeOrder(order);  // All listeners notified

// Abstract class defines the algorithm skeleton
public abstract class DataProcessor {

    // Template method - defines algorithm structure
    // Marked FINAL so subclasses can't change the flow
    public final void process() {
        Data raw = readData();         // Step 1
        Data validated = validate(raw);  // Step 2
        Data processed = transform(validated);  // Step 3
        save(processed);                 // Step 4
        notifyComplete();                // Step 5 (hook)
    }

    // Abstract methods - subclasses MUST implement
    protected abstract Data readData();
    protected abstract Data transform(Data data);

    // Concrete methods - shared implementation
    protected Data validate(Data data) {
        if (data == null) {
            throw new IllegalArgumentException("Data cannot be null");
        }
        return data;
    }

    protected abstract void save(Data data);

    // Hook - optional override (empty default)
    protected void notifyComplete() {
        // Default: do nothing
    }
}

// Concrete implementation
public class CsvDataProcessor extends DataProcessor {
    @Override
    protected Data readData() {
        return parseCsvFile();  // CSV-specific
    }

    @Override
    protected Data transform(Data data) {
        return cleanCsvData(data);  // CSV-specific
    }

    @Override
    protected void save(Data data) {
        saveToDatabase(data);
    }
}

public class JsonDataProcessor extends DataProcessor {
    @Override
    protected Data readData() {
        return parseJsonFile();  // JSON-specific
    }

    @Override
    protected Data transform(Data data) {
        return normalizeJson(data);  // JSON-specific
    }

    @Override
    protected void save(Data data) {
        saveToDatabase(data);
    }

    @Override
    protected void notifyComplete() {
        sendSlackNotification();  // Custom hook implementation
    }
}

// Usage - algorithm flow is guaranteed
DataProcessor processor = new CsvDataProcessor();
processor.process();  // Always: read → validate → transform → save → notify

// BAD: Class creates its own dependencies
public class OrderService {
    private final OrderRepository repository = new PostgresOrderRepository();
    private final EmailService emailService = new SmtpEmailService();
    private final PaymentGateway payment = new StripePaymentGateway();

    public void placeOrder(Order order) {
        repository.save(order);
        payment.charge(order.getTotal());
        emailService.send(order.getCustomer(), "Order confirmed");
    }
}

// Problems:
// - Can't test without real database, payment, email
// - Can't swap implementations (e.g., MockPaymentGateway)
// - Hard-coded dependencies = tight coupling