Java Interfaces Explained — Contracts, Default Methods and Real-World Patterns

// This file demonstrates the core contract model of interfaces.
// Imagine we're building a payment system that must support
// multiple payment providers (Stripe, PayPal, bank transfer).
// We don't want our checkout code tied to any specific provider.

// The interface defines the CONTRACT — what any payment processor must do.
public interface PaymentProcessor {

    // Abstract method: every implementor MUST provide this.
    // No body here — the 'how' is left to the class.
    boolean processPayment(String accountId, double amountInDollars);

    // Default method: added in Java 8.
    // Implementors INHERIT this but can override it if they need to.
    // This lets us add behaviour to the interface without breaking existing classes.
    default String getReceiptMessage(double amountInDollars) {
        return String.format("Payment of $%.2f processed successfully.", amountInDollars);
    }

    // Static method: belongs to the interface itself, not to any instance.
    // Call it as PaymentProcessor.validateAmount(...), never on an instance.
    static boolean validateAmount(double amountInDollars) {
        return amountInDollars > 0 && amountInDollars <= 10_000;
    }
}

// StripeProcessor signs the contract by using 'implements'.
// It MUST provide a body for processPayment, or the compiler refuses to compile it.
class StripeProcessor implements PaymentProcessor {

    @Override
    public boolean processPayment(String accountId, double amountInDollars) {
        // In real life this would call the Stripe SDK.
        // We're simulating success for any valid account.
        System.out.println("[Stripe] Charging account: " + accountId);
        return accountId != null && !accountId.isBlank();
    }
    // Note: we do NOT override getReceiptMessage — we're happy with the default.
}

// PayPalProcessor also signs the same contract.
// It provides a completely different implementation — but the same signature.
class PayPalProcessor implements PaymentProcessor {

    @Override
    public boolean processPayment(String accountId, double amountInDollars) {
        System.out.println("[PayPal] Redirecting to PayPal for account: " + accountId);
        return accountId != null && !accountId.isBlank();
    }

    // This class DOES override the default — PayPal wants a custom receipt format.
    @Override
    public String getReceiptMessage(double amountInDollars) {
        return String.format("PayPal confirmed your payment of $%.2f. Check your email.", amountInDollars);
    }
}

// Checkout doesn't know or care whether it's talking to Stripe or PayPal.
// It only knows the PaymentProcessor contract. This is the whole point.
class Checkout {

    private final PaymentProcessor processor; // typed to the INTERFACE, not a concrete class

    public Checkout(PaymentProcessor processor) {
        this.processor = processor;
    }

    public void completePurchase(String accountId, double amount) {
        // Use the static utility to validate before we even try
        if (!PaymentProcessor.validateAmount(amount)) {
            System.out.println("Invalid amount: $" + amount);
            return;
        }

        boolean success = processor.processPayment(accountId, amount);

        if (success) {
            // getReceiptMessage calls whichever version the concrete class provides
            System.out.println(processor.getReceiptMessage(amount));
        } else {
            System.out.println("Payment failed. Please try again.");
        }
    }
}

// Main entry point — wire it all together
class Main {
    public static void main(String[] args) {

        // Swap the concrete class here and NOTHING else changes
        Checkout stripeCheckout = new Checkout(new StripeProcessor());
        stripeCheckout.completePurchase("acct_1234", 49.99);

        System.out.println("---");

        Checkout paypalCheckout = new Checkout(new PayPalProcessor());
        paypalCheckout.completePurchase("pp_user_99", 49.99);

        System.out.println("---");

        // Test the static validator directly on the interface
        Checkout invalidCheckout = new Checkout(new StripeProcessor());
        invalidCheckout.completePurchase("acct_5678", -5.00);
    }
}

// A smart home device needs several unrelated capabilities.
// Using multiple interfaces lets us compose those capabilities cleanly.

// Capability 1: the device can be turned on and off
interface Switchable {
    void turnOn();
    void turnOff();

    default String getStatusMessage() {
        return "Device status updated."; // generic default
    }
}

// Capability 2: the device can report its power usage
interface PowerMonitor {
    double getCurrentWattage();

    default String getStatusMessage() {
        // Same method name as Switchable.getStatusMessage() — conflict!
        return "Power monitor status updated.";
    }
}

// Capability 3: the device can be scheduled
interface Schedulable {
    void scheduleOnAt(int hourOfDay);
    void scheduleOffAt(int hourOfDay);
}

// SmartBulb implements ALL THREE interfaces simultaneously.
// Because both Switchable and PowerMonitor have a conflicting default method,
// the compiler FORCES us to override it here. No silent ambiguity.
public class SmartBulb implements Switchable, PowerMonitor, Schedulable {

    private boolean isOn = false;
    private double wattage;
    private final String deviceName;

    public SmartBulb(String deviceName, double wattage) {
        this.deviceName = deviceName;
        this.wattage = wattage;
    }

    @Override
    public void turnOn() {
        isOn = true;
        System.out.println(deviceName + " turned ON.");
    }

    @Override
    public void turnOff() {
        isOn = false;
        System.out.println(deviceName + " turned OFF.");
    }

    @Override
    public double getCurrentWattage() {
        // Only draw power when on
        return isOn ? wattage : 0.0;
    }

    @Override
    public void scheduleOnAt(int hourOfDay) {
        System.out.printf("%s scheduled to turn ON at %02d:00%n", deviceName, hourOfDay);
    }

    @Override
    public void scheduleOffAt(int hourOfDay) {
        System.out.printf("%s scheduled to turn OFF at %02d:00%n", deviceName, hourOfDay);
    }

    // We MUST override this because both Switchable and PowerMonitor define it.
    // We can also call either parent's default using InterfaceName.super.method()
    @Override
    public String getStatusMessage() {
        // Explicitly delegate to Switchable's version, or write our own — your call.
        return deviceName + " is currently " + (isOn ? "ON" : "OFF")
               + ", drawing " + getCurrentWattage() + "W."; // our own implementation
    }

    public static void main(String[] args) {
        SmartBulb livingRoomBulb = new SmartBulb("Living Room Bulb", 9.5);

        livingRoomBulb.scheduleOnAt(18);
        livingRoomBulb.turnOn();
        System.out.println(livingRoomBulb.getStatusMessage());

        livingRoomBulb.scheduleOffAt(23);
        livingRoomBulb.turnOff();
        System.out.println(livingRoomBulb.getStatusMessage());

        // SmartBulb can be referenced by ANY of its interface types
        Switchable switchable = livingRoomBulb;
        PowerMonitor monitor = livingRoomBulb;
        // Each reference only exposes methods from that interface — intentional
        System.out.println("Wattage via monitor ref: " + monitor.getCurrentWattage() + "W");
    }
}

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

// ── STRATEGY PATTERN ──────────────────────────────────────────────
// Define a family of formatting algorithms behind one interface.
// The ReportGenerator doesn't care which format — it just calls format().

interface ReportFormatter {
    String format(String title, List<String> rows);
}

class CsvFormatter implements ReportFormatter {
    @Override
    public String format(String title, List<String> rows) {
        StringBuilder csv = new StringBuilder(title).append("\n");
        rows.forEach(row -> csv.append(row).append("\n"));
        return csv.toString();
    }
}

class HtmlFormatter implements ReportFormatter {
    @Override
    public String format(String title, List<String> rows) {
        StringBuilder html = new StringBuilder("<h1>").append(title).append("</h1><ul>");
        rows.forEach(row -> html.append("<li>").append(row).append("</li>"));
        html.append("</ul>");
        return html.toString();
    }
}

// The generator is blissfully unaware of CSV vs HTML — that's the strategy doing its job.
class ReportGenerator {
    private final ReportFormatter formatter; // holds the strategy

    public ReportGenerator(ReportFormatter formatter) {
        this.formatter = formatter;
    }

    public String generate(String title, List<String> data) {
        return formatter.format(title, data);
    }
}

// ── FUNCTIONAL INTERFACE / CALLBACK PATTERN ────────────────────────
// @FunctionalInterface enforces that this interface stays single-method.
// That means callers can use a lambda instead of writing a full class.
@FunctionalInterface
interface SalesFilter {
    boolean test(double saleAmount); // one abstract method = functional interface
}

class SalesAnalyzer {
    private final List<Double> sales;

    public SalesAnalyzer(List<Double> sales) {
        this.sales = sales;
    }

    // Accepts a SalesFilter — but callers pass a lambda. Clean and readable.
    public long countSalesMatching(SalesFilter filter) {
        return sales.stream()
                    .filter(filter::test) // the callback fires for each sale
                    .count();
    }
}

// ── MARKER INTERFACE PATTERN ───────────────────────────────────────
// No methods — purely a tag that says 'this type can be exported'
interface Exportable {
    // intentionally empty — it's a capability flag
}

class SalesReport implements Exportable {
    public final String content;
    public SalesReport(String content) { this.content = content; }
}

class InternalMemo {
    // Does NOT implement Exportable — should never leave the system
    public final String content;
    public InternalMemo(String content) { this.content = content; }
}

class ExportService {
    public void export(Object document) {
        if (document instanceof Exportable) {
            System.out.println("Exporting document to external system...");
        } else {
            // The marker stopped a dangerous operation at runtime
            System.out.println("Export BLOCKED — document is not marked Exportable.");
        }
    }
}

// ── DEMO ───────────────────────────────────────────────────────────
public class ReportGenerator {
    public static void main(String[] args) {
        List<String> salesData = Arrays.asList("Alice,500", "Bob,1200", "Carol,850");

        // Strategy: swap formatters without touching ReportGenerator
        ReportGenerator csvGen = new ReportGenerator(new CsvFormatter());
        System.out.println("=== CSV Output ===");
        System.out.println(csvGen.generate("Q1 Sales", salesData));

        ReportGenerator htmlGen = new ReportGenerator(new HtmlFormatter());
        System.out.println("=== HTML Output ===");
        System.out.println(htmlGen.generate("Q1 Sales", salesData));

        // Functional interface: pass logic as a lambda — no class needed
        SalesAnalyzer analyzer = new SalesAnalyzer(Arrays.asList(200.0, 450.0, 1100.0, 75.0, 600.0));
        long highValueSales = analyzer.countSalesMatching(amount -> amount > 400.0);
        System.out.println("High-value sales (over $400): " + highValueSales);

        // Marker interface: tag-based access control
        ExportService exporter = new ExportService();
        exporter.export(new SalesReport("Q1 data"));
        exporter.export(new InternalMemo("Do not share"));
    }
}

// This example shows the interface + abstract class combo.
// The interface defines the public contract.
// The abstract class handles boilerplate common to all notifications.
// Concrete classes only write the code that's unique to them.

// PUBLIC CONTRACT — what every notification channel must do
interface NotificationSender {
    void send(String recipientId, String message);
    boolean isAvailable(); // is this channel currently operational?
}

// ABSTRACT BASE — handles the retry logic so every subclass gets it free
// This class is not public API — it's an internal implementation helper.
abstract class AbstractNotificationSender implements NotificationSender {

    // Shared state: every channel tracks how many retries are allowed
    private final int maxRetries;
    private final String channelName;

    protected AbstractNotificationSender(String channelName, int maxRetries) {
        this.channelName = channelName;
        this.maxRetries = maxRetries;
    }

    // Template method: handles retry logic. Delegates the actual send to subclasses.
    public void sendWithRetry(String recipientId, String message) {
        int attempts = 0;
        while (attempts < maxRetries) {
            if (!isAvailable()) {
                System.out.printf("[%s] Channel unavailable. Attempt %d of %d.%n",
                                  channelName, attempts + 1, maxRetries);
                attempts++;
                continue;
            }
            send(recipientId, message);
            System.out.printf("[%s] Sent on attempt %d.%n", channelName, attempts + 1);
            return; // success — exit
        }
        System.out.printf("[%s] Failed after %d attempts.%n", channelName, maxRetries);
    }

    protected String getChannelName() {
        return channelName;
    }
}

// CONCRETE CLASS 1 — only implements what's unique to email
class EmailSender extends AbstractNotificationSender {

    private final boolean smtpServerReachable;

    public EmailSender(boolean smtpServerReachable) {
        super("Email", 3); // pass shared config to abstract class
        this.smtpServerReachable = smtpServerReachable;
    }

    @Override
    public void send(String recipientId, String message) {
        System.out.printf("[Email] Sending to %s: \"%s\"%n", recipientId, message);
    }

    @Override
    public boolean isAvailable() {
        return smtpServerReachable;
    }
}

// CONCRETE CLASS 2 — only implements what's unique to SMS
class SmsSender extends AbstractNotificationSender {

    private final boolean carrierApiOnline;

    public SmsSender(boolean carrierApiOnline) {
        super("SMS", 2);
        this.carrierApiOnline = carrierApiOnline;
    }

    @Override
    public void send(String recipientId, String message) {
        System.out.printf("[SMS] Texting %s: \"%s\"%n", recipientId, message);
    }

    @Override
    public boolean isAvailable() {
        return carrierApiOnline;
    }
}

public class NotificationSystem {
    public static void main(String[] args) {
        // Email is up, SMS carrier is down
        EmailSender email = new EmailSender(true);
        SmsSender sms = new SmsSender(false);

        System.out.println("--- Email notification ---");
        email.sendWithRetry("user@example.com", "Your order has shipped!");

        System.out.println("--- SMS notification ---");
        sms.sendWithRetry("+1-555-0199", "Your order has shipped!");

        // External code still uses the interface type — not EmailSender, not AbstractNotificationSender
        NotificationSender sender = new EmailSender(true);
        sender.send("boss@company.com", "Server is healthy.");
    }
}