Java Default Methods — Override Traps That Skip Audit Logs

// === PaymentGateway.java ===
public interface PaymentGateway {

    // Abstract method — every gateway MUST implement this
    boolean charge(String customerId, double amountInDollars);

    // Default method — shared retry logic that any gateway can use as-is or override
    default boolean chargeWithRetry(String customerId, double amountInDollars, int maxAttempts) {
        for (int attempt = 1; attempt <= maxAttempts; attempt++) {
            System.out.println("Attempt " + attempt + " of " + maxAttempts
                    + " for customer: " + customerId);

            boolean success = charge(customerId, amountInDollars); // calls the gateway-specific implementation

            if (success) {
                System.out.println("Payment succeeded on attempt " + attempt);
                return true;
            }

            System.out.println("Attempt " + attempt + " failed. Retrying...");
        }
        System.out.println("All " + maxAttempts + " attempts exhausted for customer: " + customerId);
        return false;
    }
}

// === StripeGateway.java ===
// Stripe is happy with the default retry logic — so it only implements charge()
public class StripeGateway implements PaymentGateway {

    @Override
    public boolean charge(String customerId, double amountInDollars) {
        // Simulating Stripe's API call: succeeds on first try for demo purposes
        System.out.println("  [Stripe] Charging $" + amountInDollars + " to customer " + customerId);
        return true; // pretend the API call succeeded
    }
}

// === PayPalGateway.java ===
// PayPal has a strict 2-attempt policy imposed by their contract, so it overrides the default
public class PayPalGateway implements PaymentGateway {

    @Override
    public boolean charge(String customerId, double amountInDollars) {
        System.out.println("  [PayPal] Charging $" + amountInDollars + " to customer " + customerId);
        return false; // simulating a declined card for demo
    }

    // Overriding the default: PayPal caps retries at 2 regardless of what the caller requests
    @Override
    public boolean chargeWithRetry(String customerId, double amountInDollars, int maxAttempts) {
        int cappedAttempts = Math.min(maxAttempts, 2); // contractual cap
        System.out.println("[PayPal] Retry cap enforced: " + cappedAttempts + " attempts max");
        for (int attempt = 1; attempt <= cappedAttempts; attempt++) {
            System.out.println("  [PayPal] Attempt " + attempt);
            if (charge(customerId, amountInDollars)) return true;
        }
        return false;
    }
}

// === Main.java ===
public class Main {
    public static void main(String[] args) {
        PaymentGateway stripe = new StripeGateway();
        PaymentGateway paypal = new PayPalGateway();

        System.out.println("--- Stripe with default retry logic ---");
        stripe.chargeWithRetry("cust_abc123", 49.99, 3);

        System.out.println("\n--- PayPal with overridden retry logic ---");
        paypal.chargeWithRetry("cust_xyz789", 19.99, 5); // caller asks for 5, PayPal caps at 2
    }
}

// === Auditable.java ===
// First interface — can log events for compliance
public interface Auditable {
    default String generateEventLog(String action) {
        return "[AUDIT] Action=" + action + " | Source=Auditable";
    }
}

// === Trackable.java ===
// Second interface — can log events for analytics
public interface Trackable {
    default String generateEventLog(String action) {
        return "[TRACK] Action=" + action + " | Source=Trackable";
    }
}

// === UserService.java ===
// This class implements BOTH — compiler error unless we resolve the clash!
public class UserService implements Auditable, Trackable {

    // Without this override, the code won't even compile.
    // Java says: "I see two default methods with the same signature — YOU decide."
    @Override
    public String generateEventLog(String action) {
        // We explicitly choose to use Auditable's version for compliance reasons
        // and append Trackable's version as a secondary log
        String auditEntry   = Auditable.super.generateEventLog(action);   // call Auditable's default
        String trackingEntry = Trackable.super.generateEventLog(action);  // call Trackable's default
        return auditEntry + " | " + trackingEntry;
    }

    public void createUser(String username) {
        System.out.println("Creating user: " + username);
        System.out.println(generateEventLog("CREATE_USER:" + username));
    }
}

// === Main.java ===
public class Main {
    public static void main(String[] args) {
        UserService userService = new UserService();
        userService.createUser("alice_dev");

        // Demonstrating priority rule: concrete class method always wins
        // If UserService had NOT overridden generateEventLog, it wouldn't compile.
        // The compiler refuses to guess between two equally-specific interfaces.
        System.out.println("\nDirect log call: " + userService.generateEventLog("DIRECT_TEST"));
    }
}

// === Notifiable.java ===
// Interface with a default method: models a CAPABILITY, not an identity.
// Any class can be Notifiable — a User, an Order, a Device, whatever.
public interface Notifiable {

    // Abstract — each notifiable thing must know its own recipient address
    String getRecipientAddress();

    // Default — the formatting logic is shared across all notifiable types
    default String formatNotification(String subject, String body) {
        return "TO: " + getRecipientAddress() + "\n"
             + "SUBJECT: " + subject + "\n"
             + "BODY: " + body + "\n"
             + "---";
    }
}

// === User.java ===
// User has its own class hierarchy — extending AbstractEntity (not shown).
// It CANNOT extend an abstract notification class AND AbstractEntity simultaneously.
// But it CAN implement Notifiable with zero inheritance conflict.
public class User implements Notifiable {
    private final String name;
    private final String emailAddress;

    public User(String name, String emailAddress) {
        this.name         = name;
        this.emailAddress = emailAddress;
    }

    @Override
    public String getRecipientAddress() {
        return emailAddress; // User notified by email
    }

    public String getName() { return name; }
}

// === SmartDevice.java ===
// A completely different class hierarchy — but it also wants notification formatting.
// Default method lets SmartDevice reuse the same formatting logic as User.
public class SmartDevice implements Notifiable {
    private final String deviceId;
    private final String pushToken;

    public SmartDevice(String deviceId, String pushToken) {
        this.deviceId  = deviceId;
        this.pushToken = pushToken;
    }

    @Override
    public String getRecipientAddress() {
        return pushToken; // Device notified by push token
    }
}

// === NotificationService.java ===
public class NotificationService {

    // Works with ANY Notifiable — User, SmartDevice, or anything else in the future
    public void send(Notifiable recipient, String subject, String body) {
        String message = recipient.formatNotification(subject, body); // uses default or overridden
        System.out.println("Dispatching notification:\n" + message);
    }
}

// === Main.java ===
public class Main {
    public static void main(String[] args) {
        User        alice  = new User("Alice", "alice@example.com");
        SmartDevice thermostat = new SmartDevice("thermo-001", "push_token_abc999");

        NotificationService notifier = new NotificationService();

        notifier.send(alice,      "Welcome!",         "Your account is ready.");
        notifier.send(thermostat, "Firmware Update",  "Version 3.1.2 is available.");
    }
}

// === ReportGenerator.java (Version 2.0 of your library) ===
// Version 1.0 only had generate(). Version 2.0 adds exportAsPdf() and exportAsCsv()
// as DEFAULT methods so existing implementors don't break.
public interface ReportGenerator {

    // Original v1.0 abstract method — all existing implementors already have this
    String generate(String reportTitle, java.util.List<String> dataRows);

    // NEW in v2.0 — default fallback: just wraps the text output as a "PDF"
    // Existing classes get this for free. No code changes needed on their side.
    default byte[] exportAsPdf(String reportTitle, java.util.List<String> dataRows) {
        String content = "[PDF FALLBACK]\n" + generate(reportTitle, dataRows);
        System.out.println("  (Using default PDF fallback — override for real PDF rendering)");
        return content.getBytes(); // real implementation would use a PDF library
    }

    // NEW in v2.0 — default CSV export: builds comma-separated output automatically
    default String exportAsCsv(String reportTitle, java.util.List<String> dataRows) {
        StringBuilder csv = new StringBuilder(reportTitle).append("\n");
        for (String row : dataRows) {
            csv.append(row.replace(" ", ",")).append("\n"); // naive split for demo
        }
        return csv.toString();
    }
}

// === SalesReport.java (existing v1.0 implementor — NOT modified) ===
// This class was written before v2.0. It still compiles and runs perfectly.
// It gets exportAsPdf() and exportAsCsv() as defaults for free.
public class SalesReport implements ReportGenerator {

    @Override
    public String generate(String reportTitle, java.util.List<String> dataRows) {
        StringBuilder report = new StringBuilder("=== " + reportTitle + " ===\n");
        for (String row : dataRows) {
            report.append("  - ").append(row).append("\n");
        }
        return report.toString();
    }
}

// === FinanceReport.java (a NEW v2.0 implementor that overrides exportAsPdf) ===
// Finance needs real PDF rendering, so it overrides the default.
public class FinanceReport implements ReportGenerator {

    @Override
    public String generate(String reportTitle, java.util.List<String> dataRows) {
        return "[Finance] " + reportTitle + " | Rows: " + dataRows.size();
    }

    @Override
    public byte[] exportAsPdf(String reportTitle, java.util.List<String> dataRows) {
        // In real life this would invoke iText or Apache PDFBox
        String professionalPdf = "[REAL PDF] " + generate(reportTitle, dataRows);
        System.out.println("  (Using FinanceReport's professional PDF renderer)");
        return professionalPdf.getBytes();
    }
    // Note: exportAsCsv() is NOT overridden — FinanceReport is happy with the default
}

// === Main.java ===
import java.util.List;
public class Main {
    public static void main(String[] args) {
        List<String> rows = List.of("Q1 Revenue 500000", "Q2 Revenue 620000", "Q3 Revenue 580000");

        ReportGenerator sales   = new SalesReport();
        ReportGenerator finance = new FinanceReport();

        System.out.println("--- SalesReport (v1.0 class, unmodified) ---");
        System.out.println(sales.generate("Annual Sales", rows));
        System.out.print("PDF export: ");
        byte[] salesPdf = sales.exportAsPdf("Annual Sales", rows);   // uses default
        System.out.println(new String(salesPdf));

        System.out.println("--- FinanceReport (v2.0 class with override) ---");
        System.out.println(finance.generate("Q3 Finance", rows));
        System.out.print("PDF export: ");
        byte[] financePdf = finance.exportAsPdf("Q3 Finance", rows); // uses override
        System.out.println(new String(financePdf));

        System.out.println("CSV (default for both): ");
        System.out.println(finance.exportAsCsv("Q3 Finance", rows));
    }
}

// === ValidatedPersistence.java ===
public interface ValidatedPersistence {
    default void save(String data) {
        if (data == null || data.isEmpty()) {
            throw new IllegalArgumentException("Data cannot be null or empty");
        }
        System.out.println("[Default] Saving data: " + data);
        // abstract method for actual persistence
        doSave(data);
    }
    void doSave(String data);
}

// === NaiveService.java ===
// Implements the interface but overrides save() directly — loses the validation!
public class NaiveService implements ValidatedPersistence {
    @Override
    public void save(String data) {
        // Accidentally skips validation because we thought the default would run
        System.out.println("[NaiveService] Saving directly: " + data);
        doSave(data);
    }
    @Override
    public void doSave(String data) {
        System.out.println("[NaiveService] Actual persistence: " + data);
    }
}

// === GoodService.java ===
// Correctly calls super.save() to keep the default's validation
public class GoodService implements ValidatedPersistence {
    @Override
    public void save(String data) {
        // Retain the default's validation and then add custom behaviour
        ValidatedPersistence.super.save(data);
        System.out.println("[GoodService] Post-save notification sent.");
    }
    @Override
    public void doSave(String data) {
        System.out.println("[GoodService] Actual persistence: " + data);
    }
}

// === Main.java ===
public class Main {
    public static void main(String[] args) {
        NaiveService naive = new NaiveService();
        GoodService good  = new GoodService();

        System.out.println("--- NaiveService: no validation ---");
        naive.save("validData");
        try {
            naive.save("");   // should throw, but doesn't!
        } catch (IllegalArgumentException e) {
            System.out.println("Caught: " + e.getMessage());
        }

        System.out.println("\n--- GoodService: validation preserved ---");
        good.save("validData");
        try {
            good.save("");
        } catch (IllegalArgumentException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}