Exception Handling

try {
    Files.deleteIfExists(tempFile);
} catch (SecurityException e) {
    // Deliberately ignored only if cleanup failure is non-critical.
    logger.debug("Temporary file cleanup was not permitted\
}

try {
    sendNotification();
} catch (NotificationException e) {
    // Swallowed: caller may incorrectly assume success
}

markNotificationAsSent();

try {
    throw new IOException("Database export failed");
} finally {
    throw new RuntimeException("Cleanup failed");
}
// The cleanup exception can mask the original failure.

Optional<Student> student =
    studentRepository.findByEmail(email);

student.ifPresentOrElse(
    this::showStudent,
    this::showNotFound
);

try {
    paymentGateway.charge(order);
} catch (GatewayException e) {
    throw new PaymentProcessingException(
        "Unable to process order payment\
}

try {
    publishResult(result);
} catch (PublishException e) {
    logger.error("Result publishing failed\
}

try {
    questionRepository.save(question);
} catch (SQLException e) {
    throw new QuestionPersistenceException(
        "Unable to save question\
}

try {
    saveExam();
} catch (SQLException e) {
    // Bad: failure disappears silently
}

try {
    queue.take();
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    return;
}

try {
    future.get();
} catch (ExecutionException e) {
    Throwable cause = e.getCause();

    System.out.println(
        "Task failed because: " + cause.getMessage()
    );
}

CompletableFuture
    .supplyAsync(() -> loadExam())
    .exceptionally(error -> {
        logger.error("Exam loading failed\
}

ExecutorService executor = Executors.newSingleThreadExecutor();

Future<String> future =
    executor.submit(() -> loadExam());

try {
    System.out.println(future.get());
} catch (ExecutionException e) {
    System.out.println("Task failed: " + e.getCause());
} finally {
    executor.shutdown();
}

Thread worker = new Thread(() -> {
    throw new RuntimeException("Worker failed");
});

worker.start();
// The creator thread does not catch this with its own try-catch.

Thread.setDefaultUncaughtExceptionHandler(
    (thread, exception) -> {
        logger.error(
            "Thread " + thread.getName() + " failed\
}

Thread worker = new Thread(() -> {
    throw new RuntimeException("Background task failed");
});

worker.start();

static void service() {
    try {
        throw new IllegalArgumentException("Invalid exam ID");
    } catch (IOException e) {
        System.out.println("I/O problem");
    }
}

// IllegalArgumentException is not caught here
// and propagates to the caller.

try {
    databaseConnection.commit();
} finally {
    databaseConnection.close();
}

try {
    Integer.parseInt(input);
} catch (NumberFormatException e) {
    System.out.println("Invalid number");
}

Lock lock = serviceLock;

lock.lock();
try {
    updateStudent();
} finally {
    lock.unlock();
}

Student student = studentRepository.findById(id);

try {
    System.out.println(student.getName());
} catch (NullPointerException e) {
    System.out.println("Student was not found");
}

try {
    processExam();
} finally {
    try {
        auditService.recordCompletion();
    } catch (AuditException e) {
        logger.warn("Audit cleanup failed\
}}

try {
    processPayment();
} catch (PaymentException e) {
    try {
        notifyPaymentFailure();
    } catch (NotificationException notificationError) {
        logger.error("Could not send failure notification\
}}

try {
    loadExam();

    try {
        validateQuestionBank();
    } catch (ValidationException e) {
        System.out.println("Question validation failed");
    }

} catch (IOException e) {
    System.out.println("Exam data could not be loaded");
}

try {
    Integer.parseInt("Java");
} catch (NumberFormatException e) {
    System.out.println("Message: " + e.getMessage());
    e.printStackTrace();
}

static void process() throws IOException, SQLException {
    try {
        readAndSave();
    } catch (Exception e) {
        throw e;
    }
}

class AppConfig {
    static {
        try {
            loadConfiguration();
        } catch (IOException e) {
            throw new ExceptionInInitializerError(e);
        }
    }
}

class Configuration {
    Configuration(Path file) throws IOException {
        String content = Files.readString(file);
        load(content);
    }
}

class Parent {
    void validate() {}
}

class Child extends Parent {
    @Override
    void validate() {
        throw new IllegalStateException(
            "Child is not ready"
        );
    }
}

class Parent {
    void load() throws IOException {}
}

class Child extends Parent {
    @Override
    void load() throws FileNotFoundException {
        // Allowed: FileNotFoundException is narrower
    }
}

static void calculateAverage(int total, int count) {
    if (count == 0) {
        throw new IllegalArgumentException(
            "Count must be greater than zero"
        );
    }

    System.out.println(total / count);
}