SOLID Principles Explained — With Real-World Java Examples

// BEFORE: This class violates SRP — it handles user data, email formatting,
// AND database persistence. Three different reasons to change.
class UserManagerBad {
    private String username;
    private String email;

    public UserManagerBad(String username, String email) {
        this.username = username;
        this.email = email;
    }

    // Reason 1: Business logic team asks to change validation rules
    public boolean isValidEmail() {
        return email.contains("@") && email.contains(".");
    }

    // Reason 2: UI/comms team asks to change welcome message copy
    public String formatWelcomeMessage() {
        return "Welcome, " + username + "! Your account email is " + email;
    }

    // Reason 3: Database team asks to change persistence format
    public void saveToDatabase() {
        System.out.println("INSERT INTO users VALUES ('" + username + "', '" + email + "')");
    }
}

// AFTER: Three classes, each with one clear reason to change.

// Owned by: validation/business rules team
class UserEmailValidator {
    public boolean isValid(String email) {
        // Only this class changes when email validation rules change
        return email != null && email.contains("@") && email.contains(".");
    }
}

// Owned by: communications/UI team
class UserWelcomeFormatter {
    public String format(String username, String email) {
        // Only this class changes when welcome message copy changes
        return "Welcome, " + username + "! Your account email is " + email;
    }
}

// Owned by: persistence/database team
class UserRepository {
    public void save(String username, String email) {
        // Only this class changes when the storage mechanism changes
        System.out.println("Saving user to DB: username=" + username + ", email=" + email);
    }
}

// Coordinator: thin orchestration — no logic of its own
public class SingleResponsibilityExample {
    public static void main(String[] args) {
        String username = "alice";
        String email = "alice@example.com";

        UserEmailValidator validator = new UserEmailValidator();
        UserWelcomeFormatter formatter = new UserWelcomeFormatter();
        UserRepository repository = new UserRepository();

        if (validator.isValid(email)) {
            // Each collaborator does exactly one job
            System.out.println(formatter.format(username, email));
            repository.save(username, email);
        } else {
            System.out.println("Invalid email address: " + email);
        }
    }
}

// OCP VIOLATION: Every new payment method requires editing this tested class.
class PaymentProcessorBad {
    public void process(String paymentType, double amount) {
        if (paymentType.equals("CREDIT_CARD")) {
            System.out.println("Charging credit card: $" + amount);
        } else if (paymentType.equals("PAYPAL")) {
            System.out.println("Sending PayPal request: $" + amount);
        }
        // Every new payment method means EDITING this method — risky and fragile.
    }
}

// OCP + LSP COMPLIANT DESIGN:
// The abstraction — the contract that ALL payment methods must honour.
interface PaymentMethod {
    // LSP guarantee: any class implementing this MUST process the amount
    // and return a result. No silent failures, no unexpected exceptions.
    PaymentResult process(double amount);
}

// The result object — makes success/failure explicit rather than relying on exceptions
class PaymentResult {
    private final boolean success;
    private final String message;

    public PaymentResult(boolean success, String message) {
        this.success = success;
        this.message = message;
    }

    public boolean isSuccess() { return success; }
    public String getMessage() { return message; }
}

// Extension 1: Added without touching PaymentMethod or any other class
class CreditCardPayment implements PaymentMethod {
    private final String maskedCardNumber;

    public CreditCardPayment(String maskedCardNumber) {
        this.maskedCardNumber = maskedCardNumber;
    }

    @Override
    public PaymentResult process(double amount) {
        // Honours the contract: always returns a PaymentResult, never throws unexpectedly
        System.out.println("Charging card ending in " + maskedCardNumber + ": $" + amount);
        return new PaymentResult(true, "Credit card charged successfully");
    }
}

// Extension 2: Added without touching existing code — OCP in action
class PayPalPayment implements PaymentMethod {
    private final String paypalEmail;

    public PayPalPayment(String paypalEmail) {
        this.paypalEmail = paypalEmail;
    }

    @Override
    public PaymentResult process(double amount) {
        System.out.println("PayPal transfer to " + paypalEmail + ": $" + amount);
        return new PaymentResult(true, "PayPal payment sent");
    }
}

// Extension 3: A new payment type added MONTHS later — zero changes to existing classes
class CryptoPayment implements PaymentMethod {
    private final String walletAddress;

    public CryptoPayment(String walletAddress) {
        this.walletAddress = walletAddress;
    }

    @Override
    public PaymentResult process(double amount) {
        System.out.println("Broadcasting crypto tx to " + walletAddress + ": $" + amount);
        return new PaymentResult(true, "Crypto transaction broadcast");
    }
}

// The processor is now permanently closed for modification.
// You NEVER need to edit this class again, regardless of new payment methods.
class PaymentProcessor {
    public void process(PaymentMethod paymentMethod, double amount) {
        // LSP guarantee: we call process() on any PaymentMethod — no instanceof needed.
        PaymentResult result = paymentMethod.process(amount);
        if (result.isSuccess()) {
            System.out.println("  -> Result: " + result.getMessage());
        } else {
            System.out.println("  -> FAILED: " + result.getMessage());
        }
    }
}

public class OpenClosedLiskovExample {
    public static void main(String[] args) {
        PaymentProcessor processor = new PaymentProcessor();

        // Each of these is substitutable — LSP is satisfied.
        // The processor doesn't know or care which implementation it's using.
        processor.process(new CreditCardPayment("4242"), 99.99);
        processor.process(new PayPalPayment("alice@example.com"), 49.50);
        processor.process(new CryptoPayment("0xABCDEF123456"), 250.00);
    }
}

// ─── INTERFACE SEGREGATION ───────────────────────────────────────────────────

// VIOLATION: A fat interface forces PrinterDevice to implement fax and scan
// even if the device is a basic printer that can't do either.
interface MultifunctionDeviceBad {
    void print(String document);
    void scan(String document);   // Basic printers can't scan!
    void fax(String document);    // Basic printers can't fax!
}

// FIX: Segregate into small, focused interfaces.
// Each interface represents ONE capability.
interface Printable {
    void print(String document);
}

interface Scannable {
    void scan(String document);
}

interface Faxable {
    void fax(String phoneNumber, String document);
}

// A basic printer only implements what it actually supports.
class BasicPrinter implements Printable {
    @Override
    public void print(String document) {
        // No forced stub methods, no UnsupportedOperationException hacks
        System.out.println("[BasicPrinter] Printing: " + document);
    }
}

// An enterprise device implements everything it genuinely supports.
class EnterpriseMultifunctionPrinter implements Printable, Scannable, Faxable {
    @Override
    public void print(String document) {
        System.out.println("[Enterprise] Printing: " + document);
    }

    @Override
    public void scan(String document) {
        System.out.println("[Enterprise] Scanning: " + document);
    }

    @Override
    public void fax(String phoneNumber, String document) {
        System.out.println("[Enterprise] Faxing '" + document + "' to " + phoneNumber);
    }
}

// ─── DEPENDENCY INVERSION ─────────────────────────────────────────────────────

// The abstraction — business logic depends on THIS, not on a concrete database class.
interface NotificationSender {
    void send(String recipientEmail, String subject, String body);
}

// LOW-LEVEL detail: a concrete implementation of the abstraction.
// This class knows about SMTP — the business logic class does NOT.
class SmtpEmailSender implements NotificationSender {
    @Override
    public void send(String recipientEmail, String subject, String body) {
        // In real code this would use JavaMail. Here we simulate it.
        System.out.println("[SMTP] Sending email to " + recipientEmail);
        System.out.println("  Subject: " + subject);
        System.out.println("  Body: " + body);
    }
}

// A test double — swapped in during unit tests so we don't need a real mail server.
class FakeNotificationSender implements NotificationSender {
    private String lastRecipient;  // Stored so tests can assert on it

    @Override
    public void send(String recipientEmail, String subject, String body) {
        this.lastRecipient = recipientEmail;
        System.out.println("[TEST STUB] Pretending to send email to " + recipientEmail);
    }

    public String getLastRecipient() { return lastRecipient; }
}

// HIGH-LEVEL business logic: knows nothing about SMTP, HTTP, or any concrete sender.
// The dependency is injected — this class is testable in isolation.
class OrderConfirmationService {
    // Depends on the abstraction, NOT on SmtpEmailSender directly — DIP satisfied.
    private final NotificationSender notificationSender;

    // Dependency injected via constructor — easy to swap for tests
    public OrderConfirmationService(NotificationSender notificationSender) {
        this.notificationSender = notificationSender;
    }

    public void confirmOrder(String customerEmail, String orderId) {
        // Business logic lives here — not delivery mechanism details
        String subject = "Order Confirmed: #" + orderId;
        String body = "Your order #" + orderId + " has been confirmed. Thank you!";
        notificationSender.send(customerEmail, subject, body);
        System.out.println("Order " + orderId + " confirmation processed.");
    }
}

public class InterfaceSegregationDIPExample {
    public static void main(String[] args) {
        System.out.println("=== ISP Demo ===");
        BasicPrinter basicPrinter = new BasicPrinter();
        basicPrinter.print("Q4 Financial Report");  // Works cleanly, no stub methods

        EnterpriseMultifunctionPrinter mfp = new EnterpriseMultifunctionPrinter();
        mfp.print("Contract Draft");
        mfp.scan("Signed Contract");
        mfp.fax("+1-555-0199", "Signed Contract");

        System.out.println();
        System.out.println("=== DIP Demo — Production ===");
        // In production: inject the real SMTP sender
        OrderConfirmationService prodService =
            new OrderConfirmationService(new SmtpEmailSender());
        prodService.confirmOrder("alice@example.com", "ORD-8821");

        System.out.println();
        System.out.println("=== DIP Demo — Unit Test Scenario ===");
        // In tests: inject the fake — no mail server required
        FakeNotificationSender fakeSender = new FakeNotificationSender();
        OrderConfirmationService testService = new OrderConfirmationService(fakeSender);
        testService.confirmOrder("bob@example.com", "ORD-8822");
        System.out.println("Test verified recipient: " + fakeSender.getLastRecipient());
    }
}