Java catch Keyword
Usage and Examples

catch Keyword in Java

The catch keyword in Java is part of the exception handling mechanism. It is used to handle exceptions that are thrown by the try block. Without proper handling, exceptions can crash your program. The catch block lets you respond to errors gracefully and keep the application running or at least exit cleanly.

Syntax of the catch Block

try {
    // code that might throw an exception
} catch (ExceptionType e) {
    // code to handle the exception
}

How try and catch Work Together

The try block wraps the code that you think might throw an exception. If an exception occurs, Java skips the remaining code inside try and jumps to the corresponding catch block.

Example 1: Handling ArithmeticException

public class CatchExample1 {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println("This will not print");
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero!");
        }
    }
}

Cannot divide by zero!

Explanation:

Here, dividing by zero throws an ArithmeticException. The program control immediately transfers to the catch block, which handles the error and prints a message. The line inside the try after the exception is never executed.

Example 2: Catching Multiple Exceptions

public class CatchExample2 {
    public static void main(String[] args) {
        try {
            int[] numbers = new int[3];
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Index out of range!");
        }
    }
}

Index out of range!

Example 3: Multiple catch Blocks

public class CatchExample3 {
    public static void main(String[] args) {
        try {
            String s = null;
            System.out.println(s.length());
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic Exception occurred.");
        } catch (NullPointerException e) {
            System.out.println("Null Pointer Exception caught.");
        }
    }
}

Null Pointer Exception caught.

Why Use Multiple catch Blocks?

Each catch block is specific to an exception type. Java checks them in order and executes the first one that matches. This gives you fine-grained control over how different errors are handled.

Using catch with Exception Superclass

You can also use the general Exception class to catch all exceptions, but it's recommended to catch specific ones when possible.

try {
    // risky code
} catch (Exception e) {
    System.out.println("An exception occurred: " + e.getMessage());
}

Best Practices

• Always catch the most specific exceptions first.
• Avoid using a blank catch block — it hides problems.
• Log or display the exception to help with debugging.
• Don’t use catch (Exception e) unless you really need to catch any possible exception.

Conclusion

The catch keyword is essential for writing robust Java programs. It prevents your application from crashing due to unexpected errors. Whether you're reading user input, performing calculations, or accessing files — catch allows you to anticipate and respond to problems proactively.