Java Exception Handling

What is Exception Handling?

An exception is an unexpected event that occurs during program execution and disrupts the normal flow. Exception handling is a mechanism to handle runtime errors gracefully, so your program doesn't crash suddenly.

Think of it like a safety net in a circus - if something goes wrong, the net catches you instead of letting you fall!

• Without exception handling: Program crashes with ugly error messages
• With exception handling: Program handles the error and continues or exits gracefully
• Benefits: Better user experience, easier debugging, more professional applications

Problem: Without Exception Handling

See what happens when we don't handle exceptions - the program crashes:

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        int result = a / b;  // Division by zero!
        System.out.println("Result: " + result);
        System.out.println("Program ended");  // Never executes
    }
}

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Main.main(Main.java:5)

Explanation:

• Program crashes at line 5 when trying to divide by zero
• Rest of the code never executes
• User sees a confusing error message

Solution: Using Try-Catch Block

Now let's handle the same error gracefully using try-catch:

public class Main {
    public static void main(String[] args) {
        try {
            int a = 10;
            int b = 0;
            int result = a / b;  // This will cause exception
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: Cannot divide by zero!");
            System.out.println("Please enter a non-zero number.");
        }
        System.out.println("Program continues normally");
    }
}

Error: Cannot divide by zero!
Please enter a non-zero number.
Program continues normally

Explanation:

• try block contains code that might throw an exception
• catch block catches the exception and handles it gracefully
• Program doesn't crash - it continues executing after the catch block
• User gets a friendly error message instead of technical jargon

Types of Exceptions

Multiple Catch Blocks

You can have multiple catch blocks to handle different types of exceptions:

public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println("Number: " + numbers[5]);  // ArrayIndexOutOfBoundsException
            
            int result = 10 / 0;  // ArithmeticException
            
            String text = null;
            System.out.println(text.length());  // NullPointerException
            
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: Array index is out of range!");
        } catch (ArithmeticException e) {
            System.out.println("Error: Cannot divide by zero!");
        } catch (NullPointerException e) {
            System.out.println("Error: Trying to use null object!");
        } catch (Exception e) {
            System.out.println("Error: Something went wrong!");
        }
        
        System.out.println("Program continues...");
    }
}

Error: Array index is out of range!
Program continues...

Explanation:

• Multiple catch blocks handle different exception types
• First matching catch block executes, others are skipped
• Keep specific exceptions first, general exception (Exception) last
• Only the array exception occurs, so only that catch block runs

The Finally Block

The finally block always executes, whether an exception occurs or not - perfect for cleanup tasks:

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Opening file...");
            int result = 10 / 0;  // Exception occurs
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: Division by zero!");
        } finally {
            System.out.println("Closing file...");
            System.out.println("Cleanup completed!");
        }
        
        System.out.println("Program ends");
    }
}

Opening file...
Error: Division by zero!
Closing file...
Cleanup completed!
Program ends

Explanation:

• finally block executes regardless of whether exception occurs
• Perfect for closing files, database connections, or releasing resources
• Ensures cleanup code always runs
• Even if exception is not caught, finally block still executes

Throw Keyword

You can manually throw an exception using the throw keyword:

public class Main {
    
    static void checkAge(int age) {
        if (age < 18) {
            throw new ArithmeticException("Access denied - Must be 18+");
        } else {
            System.out.println("Access granted - Welcome!");
        }
    }
    
    public static void main(String[] args) {
        try {
            checkAge(15);  // This will throw exception
        } catch (ArithmeticException e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }
}

Exception: Access denied - Must be 18+

Explanation:

• throw keyword manually creates and throws an exception
• Used for custom validation and error conditions
• getMessage() retrieves the exception message
• Useful for enforcing business rules in your application

Throws Keyword

The throws keyword declares that a method might throw an exception - caller must handle it:

public class Main {
    
    // Method declares it might throw exception
    static void validateAge(int age) throws ArithmeticException {
        if (age < 18) {
            throw new ArithmeticException("Not eligible to vote");
        }
        System.out.println("You can vote!");
    }
    
    public static void main(String[] args) {
        try {
            validateAge(16);  // Caller must handle exception
            validateAge(20);
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}

Caught: Not eligible to vote

Explanation:

• throws in method signature warns that method might throw exception
• Caller of the method must handle the exception using try-catch
• Different from throw - throws declares, throw actually throws
• Multiple exceptions can be declared: throws IOException, SQLException

Common Java Exceptions

• ArithmeticException: Division by zero or invalid arithmetic operation
• NullPointerException: Trying to use an object that is null
• ArrayIndexOutOfBoundsException: Accessing array with invalid index
• NumberFormatException: Converting invalid string to number
• IOException: Input/output operation failed (file operations)
• FileNotFoundException: File not found at specified path
• ClassNotFoundException: Class not found at runtime
• IllegalArgumentException: Method received illegal argument

Practical Example: Complete Exception Handling

Here's a real-world example combining multiple concepts:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        try {
            System.out.print("Enter first number: ");
            int num1 = Integer.parseInt(sc.nextLine());
            
            System.out.print("Enter second number: ");
            int num2 = Integer.parseInt(sc.nextLine());
            
            int result = num1 / num2;
            System.out.println("Result: " + result);
            
        } catch (NumberFormatException e) {
            System.out.println("Error: Please enter valid numbers only!");
        } catch (ArithmeticException e) {
            System.out.println("Error: Cannot divide by zero!");
        } catch (Exception e) {
            System.out.println("Error: Something unexpected happened!");
        } finally {
            sc.close();
            System.out.println("Scanner closed.");
        }
        
        System.out.println("Thank you for using our calculator!");
    }
}

Enter first number: abc
Error: Please enter valid numbers only!
Scanner closed.
Thank you for using our calculator!

Explanation:

• Handles invalid number format (letters instead of numbers)
• Handles division by zero error
• General exception catch for unexpected errors
• Finally block ensures Scanner is always closed
• Program ends gracefully with thank you message

Best Practices

• Be specific: Catch specific exceptions rather than generic Exception
• Don't ignore exceptions: Always handle them properly, don't leave catch blocks empty
• Use finally for cleanup: Close resources in finally block
• Meaningful messages: Provide clear error messages to users
• Log exceptions: Keep track of errors for debugging
• Don't catch everything: Only catch exceptions you can meaningfully handle
• Order matters: Put specific exceptions before general ones

Key Takeaways

• try-catch: Wrap risky code in try, handle errors in catch
• finally: Always executes - perfect for cleanup operations
• throw: Manually throw an exception when needed
• throws: Declare that method might throw exception
• Multiple catches: Handle different exception types differently
• Better UX: Graceful error handling = happy users