Exception Handling: Try-Catch, Throw, Custom Exceptions, and Best Practices

Key Concepts and Definitions

What is an Exception?

An exception is an unexpected or exceptional event that disrupts the normal flow of a program. Java provides a structured way to handle these events using exception handling.

Types of Exceptions

Exceptions in Java are categorized into two main types:

1. Checked Exceptions: Compile-time exceptions (e.g., IOException, SQLException). The compiler forces you to handle them.
2. Unchecked Exceptions: Runtime exceptions (e.g., NullPointerException, ArrayIndexOutOfBoundsException). The compiler does not enforce handling.

classDiagram
    class Exception {
        <<abstract>>
        +handle()
    }
    class RuntimeException {
        <<extends>>
        +unchecked
    }
    class IOException {
        <<extends>>
        +checked
    }
    class SQLException {
        <<extends>>
        +checked
    }
    Exception <|-- RuntimeException
    Exception <|-- IOException
    Exception <|-- SQLException

The Exception Hierarchy

graph TD
    A["Throwable"] --> B["Error"]
    A --> C["Exception"]
    C --> D["Checked Exception"]
    C --> E["Unchecked Exception"]
    D --> F["IOException"]
    D --> G["SQLException"]
    E --> H["RuntimeException"]
    E --> I["NullPointerException"]
    E --> J["ArrayIndexOutOfBoundsException"]

Exception Handling Mechanisms

1. try-catch-finally Block

The try block contains code that might throw an exception. The catch block handles the exception, and the finally block executes regardless of whether an exception occurs.

Syntax:

try {
    // Code that may throw an exception
} catch (ExceptionType e) {
    // Handle the exception
} finally {
    // Cleanup code (e.g., closing resources)
}

Example: Handling ArithmeticException

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        int a = 10, b = 0;
        try {
            int result = a / b; // Throws ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero: " + e.getMessage());
        } finally {
            System.out.println("This always executes.");
        }
    }
}

Output:

Cannot divide by zero: / by zero
This always executes.

2. throw and throws

• throw: Used to explicitly throw an exception.
• throws: Used in method signatures to declare exceptions that the method might throw.

Example: Custom Exception

class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Insufficient funds: " + (amount - balance));
        }
        balance -= amount;
        System.out.println("Withdrawn: " + amount);
    }
}

Real-World Example: Bank Withdrawal

Imagine a Khalti or Nabil Bank app where a user tries to withdraw more money than their balance. The app uses throw to raise an InsufficientFundsException and displays a user-friendly message like:

"Your account has only Rs. 5,000. Withdrawal failed."

3. Custom Exceptions

You can create your own exceptions by extending the Exception or RuntimeException class.

Example: InvalidAgeException

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

public class AgeValidator {
    public static void validateAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age must be at least 18.");
        }
        System.out.println("Age is valid.");
    }
}

Real-World Example: eSewa Registration

When registering for eSewa, if a user enters an age below 18, the system throws a custom InvalidAgeException and prompts:

"You must be 18 or older to register."

Multi-Catch Block

Java allows handling multiple exceptions in a single catch block using the | operator.

Example:

try {
    int[] arr = new int[5];
    arr[10] = 50; // ArrayIndexOutOfBoundsException
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
    System.out.println("Error: " + e.getMessage());
}

Nested try-catch Blocks

You can nest try-catch blocks to handle exceptions at different levels.

Example:

try {
    try {
        int result = 10 / 0; // ArithmeticException
    } catch (ArithmeticException e) {
        System.out.println("Inner catch: " + e);
        throw new ArrayIndexOutOfBoundsException("Nested exception");
    }
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Outer catch: " + e);
}

Best Practices for Exception Handling

1. Catch Specific Exceptions: Avoid catching generic Exception unless necessary.
2. Use Custom Exceptions: Improve code readability and maintainability.
3. Clean Up Resources: Use finally or try-with-resources to close files, connections, etc.
4. Log Exceptions: Use logging frameworks (e.g., java.util.logging) for debugging.
5. Avoid Empty Catch Blocks: Always handle or log exceptions.

In the Real World

1. Khalti App (Nepal):

   • Uses try-catch to handle network failures when processing transactions. If the server is down, it shows:

     "Payment failed. Please check your internet connection."

   • Custom exceptions like InsufficientBalanceException are thrown when a user tries to pay more than their available balance.

2. Ncell Recharge System:

   • Validates input (e.g., phone number format) using try-catch. If invalid, it throws a InvalidInputException and asks the user to re-enter details.

3. Daraz Order Processing:

   • Uses try-finally to ensure order details are saved to a database even if an error occurs during payment processing. If the payment fails, it rolls back the order and notifies the user.

Exam Tip

• Understand the difference between checked and unchecked exceptions.
• Practice writing try-catch-finally blocks for common exceptions like ArithmeticException, NullPointerException, and IOException.
• Know how to create custom exceptions and when to use them.
• Be familiar with throw vs. throws:
  • throw is used inside a method to raise an exception.
  • throws is used in the method signature to declare exceptions.
• Expect questions on:
  • Handling multiple exceptions with multi-catch.
  • Nested try-catch blocks.
  • Best practices (e.g., logging, resource cleanup).

Worked Example: File Handling with Exception Handling

import java.io.*;

public class FileReaderExample {
    public static void main(String[] args) {
        File file = new File("example.txt");
        try {
            FileReader fr = new FileReader(file);
            BufferedReader br = new BufferedReader(fr);
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
            br.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
}

State After Each Step:

1. File Creation:

   flowchart TD
       A["File: example.txt"] -->|"Exists?"| B{"No"}
       B --> C["FileNotFoundException thrown"]

2. File Reading:

   flowchart TD
       A["FileReader opened"] --> B["BufferedReader reads line"]
       B --> C["Line printed"]
       C --> D["Loop continues"]

3. Exception Handling:

   flowchart TD
       A["IOException occurs"] --> B["Caught in catch block"]
       B --> C["Error message displayed"]

Real-World Tie-In: NTC Website

When you try to download a NTC form (e.g., vehicle registration) but the file is corrupted, the website’s backend uses try-catch to handle the IOException and displays:

"File corrupted. Please try again later."

Comparison Table: Checked vs. Unchecked Exceptions

Summary of Key Points

• Exceptions disrupt normal program flow but can be handled gracefully.
• Use try-catch-finally to manage exceptions and ensure cleanup.
• Custom exceptions improve code clarity and maintainability.
• Real-world applications (e.g., Khalti, Ncell) rely on exception handling for robustness.
• Always follow best practices: catch specific exceptions, log errors, and avoid empty catch blocks.