Exception Handling

static void setLimit(int limit) {
    if (limit < 0) {
        throw new IllegalArgumentException(
            "Limit cannot be negative"
        );
    }
}

Throwable
├── Exception
│   └── RuntimeException
└── Error
    └── StackOverflowError

List<byte[]> data = new ArrayList<>();

while (true) {
    data.add(new byte[1024 * 1024]);
}

// Eventually the JVM may throw OutOfMemoryError.

static void recurse() {
    recurse();
}

// recurse(); // eventually causes StackOverflowError

try {
    runApplication();
} catch (Exception e) {
    logger.error("Application failure\
}

try {
    Files.readString(Path.of("data.txt"));
} catch (IOException e) {
    System.out.println("Recoverable I/O problem");
}

// Do not normally catch OutOfMemoryError as normal application flow.

try {
    System.out.println("Starting shutdown");
    System.exit(0);
} finally {
    System.out.println("Cleanup");
}

static int calculateScore() {
    try {
        return 80;
    } finally {
        return 100;
    }
}

System.out.println(calculateScore()); // 100

try {
    throw new IOException("File processing failed");
} finally {
    throw new RuntimeException("Cleanup failed");
}

try {
    processPayment();
} catch (PaymentException e) {
    throw new PaymentServiceException(
        "Payment recovery failed\
}

try {
    importQuestions();
} catch (IOException | SQLException e) {
    logger.error("Question import failed\
}

try {
    Files.readString(Path.of("questions.txt"));
} catch (FileNotFoundException e) {
    System.out.println("Question file missing");
} catch (IOException e) {
    System.out.println("General I/O failure");
}

try {
    Files.readString(Path.of(fileName));
} catch (FileNotFoundException e) {
    System.out.println("File does not exist");
} catch (IOException e) {
    System.out.println("Other I/O failure");
}

static void register(Student student) {
    if (student == null) {
        throw new IllegalArgumentException(
            "Student is required"
        );
    }

    saveStudent(student);
}

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

try {
    paymentService.charge(order);
} catch (PaymentException e) {
    logger.error("Payment processing failed\
}

class Exam {
    private boolean started;

    void submit() {
        if (!started) {
            throw new IllegalStateException(
                "Exam has not started"
            );
        }

        System.out.println("Exam submitted");
    }
}

static void setPassingMark(int mark) {
    if (mark < 0 || mark > 100) {
        throw new IllegalArgumentException(
            "Mark must be between 0 and 100"
        );
    }
}

Student student = findStudent(studentId);

if (student == null) {
    System.out.println("Student not found");
    return;
}

System.out.println(student.getName());

final int maxAttempts = 3;

try {
    login();
} finally {
    releaseResources();
}

// Do not use finalize() for resource cleanup.

class Resource implements AutoCloseable {
    public void close() throws Exception {
        throw new Exception("Closing failed");
    }
}

try (Resource resource = new Resource()) {
    throw new Exception("Main operation failed");
} catch (Exception e) {
    System.out.println("Primary: " + e.getMessage());

    for (Throwable suppressed : e.getSuppressed()) {
        System.out.println(
            "Suppressed: " + suppressed.getMessage()
        );
    }
}

try (BufferedReader reader =
         Files.newBufferedReader(Path.of("questions.txt"))) {

    System.out.println(reader.readLine());

} catch (IOException e) {
    System.out.println("Unable to read questions");
}

try {
    paymentService.charge(order);
} catch (PaymentDeclinedException e) {
    // This layer understands how to handle this condition.
    showPaymentFailure();
}

try {
    userRepository.save(user);
} catch (SQLException e) {
    throw new UserServiceException(
        "Unable to save user\
}

class ExamAlreadySubmittedException extends RuntimeException {
    ExamAlreadySubmittedException(String message) {
        super(message);
    }
}

if (exam.isSubmitted()) {
    throw new ExamAlreadySubmittedException(
        "This exam has already been submitted"
    );
}

class Student {
    Student(String name) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Student name is required");
        }
    }
}

try {
    Student student = new Student(null);
} catch (IllegalArgumentException e) {
    System.out.println("Student creation failed");
}

static void repository() {
    throw new RuntimeException("Database unavailable");
}

static void service() {
    repository();
}

static void controller() {
    try {
        service();
    } catch (RuntimeException e) {
        System.out.println("Handled by controller");
    }
}

static void validateAge(int age) {
    if (age < 18) {
        throw new IllegalArgumentException("Age must be 18 or older");
    }
}

static String readConfig() throws IOException {
    return Files.readString(Path.of("config.properties"));
}

Lock lock = serviceLock;

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

try {
    int mark = Integer.parseInt(input);
    System.out.println(mark);
} catch (NumberFormatException e) {
    System.out.println("Mark must be a number");
}