Exception Handling Architecture

import java.util.*;

public class Main {
    // ── Base type for your whole domain. Unchecked (RuntimeException) by
    //    default: callers shouldn't be FORCED to catch business errors. ──
    static class AppException extends RuntimeException {
        private final String code;                 // machine-readable error code
        AppException(String message, String code, Throwable cause) {
            super(message, cause);                 // pass cause -> chain preserved
            this.code = code;
        }
        AppException(String message, String code) { this(message, code, null); }
        String getCode() { return code; }
    }

    // A whole family of related errors, all sharing one base type.
    static class ValidationException extends AppException {
        private final String field;
        ValidationException(String field, String message) {
            super(message, "VALIDATION");          // code travels with the type
            this.field = field;
        }
        String getField() { return field; }
    }
    static class NotFoundException extends AppException {
        NotFoundException(String entity, long id) {
            super(entity + " " + id + " not found", "NOT_FOUND");
        }
    }
    static class PaymentException extends AppException {       // module sub-tree
        PaymentException(String message, Throwable cause) {
            super(message, "PAYMENT", cause);
        }
    }

    public static void main(String[] args) {
        // Each error knows its own code AND its own human message.
        List<AppException> errors = List.of(
            new ValidationException("email", "Invalid email format"),
            new NotFoundException("User", 42),
            new PaymentException("Card declined", new IllegalStateException("gateway 402"))
        );

        // ONE catch type (AppException) handles the whole family — that is the
        // payoff of a hierarchy. You still get each subclass's specific data.
        for (AppException e : errors) {
            System.out.println("[" + e.getCode() + "] " + e.getMessage());
            if (e instanceof ValidationException v) {
                System.out.println("    field = " + v.getField());
            }
            if (e.getCause() != null) {
                System.out.println("    cause = " + e.getCause().getMessage());
            }
        }
    }
}

[VALIDATION] Invalid email format
    field = email
[NOT_FOUND] User 42 not found
[PAYMENT] Card declined
    cause = gateway 402

public class Main {
    // Low-level "infrastructure" exception — leaks the implementation (SQL).
    static class SqlException extends Exception {
        SqlException(String message) { super(message); }
    }

    // High-level domain exception the rest of the app understands.
    static class RepositoryException extends RuntimeException {
        RepositoryException(String message, Throwable cause) { super(message, cause); }
    }

    // Pretend this talks to a database and fails.
    static void runQuery(String sql) throws SqlException {
        throw new SqlException("ORA-00942: table USERS does not exist");
    }

    // The repository TRANSLATES the low-level checked exception into a
    // domain exception — and passes the original as the cause.
    static String loadUser(long id) {
        try {
            runQuery("SELECT * FROM users WHERE id=" + id);
            return "user-" + id;
        } catch (SqlException e) {
            // ✅ Wrap: new message for context, original kept as cause.
            throw new RepositoryException("Could not load user " + id, e);
        }
    }

    public static void main(String[] args) {
        try {
            loadUser(7);
        } catch (RepositoryException e) {
            System.out.println("Top-level message : " + e.getMessage());
            // Walk the cause chain to find the real root problem.
            Throwable root = e;
            while (root.getCause() != null) root = root.getCause();
            System.out.println("Root cause        : " + root.getMessage());
            System.out.println("Root cause type   : " + root.getClass().getSimpleName());
        }
    }
}

Top-level message : Could not load user 7
Root cause        : ORA-00942: table USERS does not exist
Root cause type   : SqlException

public class Main {
    static class ConfigException extends RuntimeException {
        // 👉 1) Add a constructor that takes (String message, Throwable cause)
        //        and calls super(message, cause) so the cause is preserved.
        ___
    }

    static int parsePort(String raw) {
        try {
            return Integer.parseInt(raw);
        } catch (NumberFormatException e) {
            // 🎯 YOUR TURN — translate the low-level error into a domain one.
            // 👉 2) Throw a ConfigException with a helpful message AND pass 'e'
            //        as the cause (do NOT just use e.getMessage()).
            throw ___;
        }
    }

    public static void main(String[] args) {
        try {
            parsePort("eighty");
        } catch (ConfigException e) {
            System.out.println("Message: " + e.getMessage());
            System.out.println("Cause  : " + e.getCause().getClass().getSimpleName());
        }
    }
}

// ✅ Expected output:
// Message: Invalid port: eighty
// Cause  : NumberFormatException

import java.util.Optional;

public class Main {
    // EXPECTED failure (item simply might not exist) -> no exception needed.
    static Optional<String> findItem(String[] items, String target) {
        for (String item : items) {
            if (item.equals(target)) return Optional.of(item);
        }
        // 🎯 YOUR TURN — model "not found" as absence, not an exception.
        // 👉 1) Return an EMPTY Optional instead of throwing.
        return ___;
    }

    public static void main(String[] args) {
        String[] menu = {"coffee", "tea", "juice"};

        // 👉 2) Look up "tea", then "soda". Use orElse to supply a default
        //        message when the Optional is empty.
        System.out.println(findItem(menu, "tea").orElse("not on the menu"));
        System.out.println(findItem(menu, ___).orElse("not on the menu"));
    }
}

// ✅ Expected output:
// tea
// not on the menu

import java.lang.ref.Cleaner;

public class Main {
    // A resource that MUST be released. AutoCloseable -> usable in try-with-resources.
    static class Connection implements AutoCloseable {
        private final String name;
        Connection(String name) {
            this.name = name;
            System.out.println("  OPEN  " + name);
        }
        void query() { System.out.println("  query on " + name); }
        @Override public void close() { System.out.println("  CLOSE " + name); }
    }

    // A safety net using Cleaner: runs IF the object is GC'd without close().
    // It's a backstop, NOT a replacement for try-with-resources.
    static final Cleaner CLEANER = Cleaner.create();
    static class Buffer implements AutoCloseable {
        private final Cleaner.Cleanable cleanable;
        Buffer() {
            // The cleanup action must NOT capture 'this' (would prevent GC).
            cleanable = CLEANER.register(this, () -> System.out.println("  cleaner ran (leak backstop)"));
        }
        @Override public void close() { cleanable.clean(); }
    }

    public static void main(String[] args) {
        System.out.println("try-with-resources (auto close, even on error):");
        // Both resources close automatically, in REVERSE order, even if query throws.
        try (Connection db = new Connection("db");
             Connection cache = new Connection("cache")) {
            db.query();
            cache.query();
        }

        System.out.println("\nexplicit close() triggers the Cleaner action:");
        try (Buffer b = new Buffer()) {
            System.out.println("  using buffer");
        }

        System.out.println("\nglobal handler for anything that escapes a thread:");
        Thread.setDefaultUncaughtExceptionHandler((t, ex) ->
            System.out.println("  [GLOBAL] " + ex.getClass().getSimpleName() + ": " + ex.getMessage()));
        Thread worker = new Thread(() -> { throw new IllegalStateException("unhandled in worker"); });
        worker.start();
        try { worker.join(); } catch (InterruptedException ignored) {}
    }
}

try-with-resources (auto close, even on error):
  OPEN  db
  OPEN  cache
  query on db
  query on cache
  CLOSE cache
  CLOSE db

explicit close() triggers the Cleaner action:
  using buffer
  cleaner ran (leak backstop)

global handler for anything that escapes a thread:
  [GLOBAL] IllegalStateException: unhandled in worker

public class Main {
    // 🎯 MINI-CHALLENGE: a "fail-fast" validator with exception translation
    //
    // 1. Create a base unchecked exception: OrderException(String, Throwable)
    //    that extends RuntimeException and calls super(message, cause).
    // 2. Create ValidationException extends OrderException (cause can be null).
    // 3. Write validate(int quantity, double price):
    //      - throw a ValidationException IMMEDIATELY (fail-fast) if
    //        quantity <= 0  ("quantity must be positive")
    //      - or if price < 0 ("price cannot be negative")
    // 4. Write placeOrder(...) that calls a flaky charge() which throws
    //    IllegalStateException; CATCH it and TRANSLATE to OrderException,
    //    passing the original as the cause (preserve it!).
    // 5. In main, call validate(0, 5.0) and print the message; then call
    //    placeOrder(...) and print both getMessage() and getCause().
    //
    // ✅ Expected (example):
    //   Validation failed: quantity must be positive
    //   Order failed: payment error  (cause: IllegalStateException)

    // your code here
}