Java Multi-Catch: Catch Multiple Exceptions in One Catch Clause

You will learn how to use Java's multi-catch syntax to handle several exception types with one catch block. You will also learn the important rules: use | between exception types, do not include a subclass and its superclass together, and remember that the caught exception variable is effectively final.

Java exceptions let a program respond to unusual or failed situations without crashing unexpectedly. A try block contains code that may fail, while a catch block specifies what to do when a particular exception is thrown.

When multiple exception types need exactly the same handling, Java provides multi-catch, available since Java 7. Rather than writing several identical catch blocks, list exception types separated by the pipe character (|).

catch (ExceptionTypeA | ExceptionTypeB exception) {
    // Shared recovery or reporting code
}

For the exceptions in the question:

try {
    // Code that may throw these exceptions
} catch (IllegalArgumentException | SecurityException |
         IllegalAccessException | NoSuchFieldException e) {
    someCode();
}

This reduces duplication and makes it clear that all listed failures receive the same treatment.

Multi-catch is appropriate only when the response is truly shared. If each exception needs a different message, recovery action, or return value, separate catch blocks are usually clearer.

Think of a catch block as a service desk for errors.

• Separate catch blocks are separate service desks: one for each kind of problem.
• A multi-catch block is one shared service desk with several signs above it: “We handle IllegalArgumentException, SecurityException, IllegalAccessException, and NoSuchFieldException.”

Any of those listed exceptions can arrive at the same desk, and the same process, someCode(), is used for all of them.

Use | between exception class names, then declare one exception variable after the final type.

try {
    String text = null;
    System.out.println(text.length());
} catch (NullPointerException | IllegalArgumentException e) {
    System.out.println("The input could not be processed.");
}

If text.length() throws a NullPointerException, Java enters the shared catch block.

For the original set of exceptions:

try {
    Class<?> type = Class.forName("example.User");
    type.getDeclaredField("id");
} catch (IllegalArgumentException | SecurityException |
         IllegalAccessException | NoSuchFieldException e) {
    someCode();
}

The exception variable e refers to whichever exception was actually thrown. You can log it or inspect common methods inherited from Throwable:

try {
    performReflection();
} catch (IllegalAccessException | NoSuchFieldException e) {
    System.err.println("Reflection failed: " + e.getMessage());
}

The compiler treats e as a common type broad enough for all listed exceptions, so use only operations available to all of them unless you check the runtime type.

Consider this example:

public class MultiCatchDemo {
    public static void main(String[] args) {
        try {
            int age = Integer.parseInt("not-a-number");
            System.out.println(age);
        } catch (NumberFormatException | SecurityException e) {
            System.out.println("Could not read the age.");
            System.out.println("Reason: " + e.getClass().getSimpleName());
        }
    }
}

Execution proceeds as follows:

1. Java enters the try block.
2. Integer.parseInt("not-a-number") cannot convert the text to an integer.
3. It throws a NumberFormatException.
4. Java checks whether the exception matches either type in the multi-catch.
5. NumberFormatException is listed, so Java enters the catch block.
6. The first println displays Could not read the age.
7. e.getClass().getSimpleName() identifies the actual exception type and displays NumberFormatException.
8. The line that prints age is skipped because the exception interrupted the try block.

If no exception occurs, Java skips the catch block entirely.

Multi-catch is useful when different failures have one safe, consistent response.

• Reflection utilities: Handle NoSuchFieldException and IllegalAccessException by reporting that metadata could not be read.
• File and parsing tasks: Handle several input-related exceptions by showing one “invalid import file” message.
• Configuration loading: Treat several validation failures as an invalid configuration and use defaults.
• API boundaries: Convert a small group of low-level exceptions into one application-level error response.
• Command-line tools: Print a single failure message and return a nonzero exit code for related errors.

Example: a configuration reader may reject malformed values and missing required access in the same way.

try {
    loadConfiguration();
} catch (IllegalArgumentException | SecurityException e) {
    System.err.println("Configuration could not be loaded.");
    useDefaultConfiguration();
}

In real projects, multi-catch is commonly used at a boundary where several technical failures lead to the same business decision.

Log once and fail safely

public UserProfile readProfile(Class<?> type) {
    try {
        return readProfileWithReflection(type);
    } catch (IllegalAccessException | NoSuchFieldException e) {
        logger.warn("Profile metadata could not be read for {}", type.getName(), e);
        return UserProfile.empty();
    }
}

Validate early with guard clauses

Use validation before risky code when possible. This produces more precise errors and reduces exceptions used for normal control flow.

public void updateEmail(String email) {
    if (email == null || email.isBlank()) {
        throw new IllegalArgumentException("Email is required");
    }

    saveEmail(email);
}

Preserve different handling when it matters

If one exception requires a retry but another requires a user-facing validation message, do not combine them merely to make the code shorter.

try {
    saveRecord(record);
} catch (SecurityException e) {
    showPermissionMessage();
} catch (IllegalArgumentException e) {
    showValidationMessage();
}

Wrap implementation details at a layer boundary

A service may catch several reflection exceptions and expose one domain-specific exception:

try {
    return mapper.map(source);
} catch (IllegalAccessException | NoSuchFieldException e) {
    throw new MappingException("Could not map source data", e);
}

This keeps callers from depending on low-level implementation details.

Including a subclass and its superclass

Java rejects a multi-catch where one listed type is a subtype of another. IllegalArgumentException is a subclass of RuntimeException.

// Does not compile
try {
    runTask();
} catch (RuntimeException | IllegalArgumentException e) {
    System.out.println(e.getMessage());
}

RuntimeException already catches IllegalArgumentException, so the second type would be redundant. Catch only the superclass, or catch the specific types separately when behavior differs.

try {
    runTask();
} catch (RuntimeException e) {
    System.out.println(e.getMessage());
}

Reassigning the multi-catch variable

A multi-catch variable is implicitly final and cannot be reassigned.

// Does not compile
try {
    runTask();
} catch (IllegalArgumentException | SecurityException e) {
    e = new IllegalArgumentException("replacement");
}

Instead, create a separate variable if you need one:

try {
    runTask();
} catch (IllegalArgumentException | SecurityException e) {
    Exception replacement = new IllegalArgumentException("replacement");
    System.out.println(replacement.getMessage());
}

Catching exceptions that cannot be thrown

Checked exceptions such as IllegalAccessException and NoSuchFieldException must be possible from code in the try block. Otherwise, Java reports a compile-time error.

// Does not compile: no code here can throw NoSuchFieldException
try {
    System.out.println("Hello");
} catch (NoSuchFieldException e) {
    System.out.println(e.getMessage());
}

Combining exceptions with different recovery requirements

Avoid one generic message when users or callers need distinct outcomes. Separate catches are more maintainable when the next action differs.

Catching Exception just to avoid listing types

try {
    runTask();
} catch (Exception e) {
    // Too broad in many situations
}

This can accidentally hide unrelated bugs. Prefer specific exception types or a carefully chosen application exception.

Multi-catch versus a superclass catch

// Multi-catch: explicit list of accepted failures
catch (IllegalAccessException | NoSuchFieldException e) {
    reportMetadataFailure(e);
}

// Superclass catch: all subclasses are included
catch (ReflectiveOperationException e) {
    reportMetadataFailure(e);
}

A superclass catch is concise if the exception hierarchy exactly matches your intent. Multi-catch is clearer when you want only selected, unrelated exception types.

Multi-catch versus duplicate code

// Repeated handling
catch (IllegalAccessException e) {
    someCode();
} catch (NoSuchFieldException e) {
    someCode();
}

// Shared handling
catch (IllegalAccessException | NoSuchFieldException e) {
    someCode();
}

Use multi-catch when the bodies would otherwise remain the same.

try {
    riskyOperation();
} catch (FirstException | SecondException e) {
    handleFailure(e);
}

• Java multi-catch has been available since Java 7.
• Separate exception types with |, not commas.
• Declare one exception variable after the final type.
• The shared variable represents the exception that was actually thrown.
• A multi-catch variable cannot be reassigned.
• Do not list both a superclass and one of its subclasses.
• Checked exception types must be throwable by code in the try block.
• Use multi-catch only when the handling is the same.
• Put more specific catches before broader catches when using separate catch clauses.

catch (IllegalArgumentException | SecurityException |
       IllegalAccessException | NoSuchFieldException e) {
    someCode();
}

Can Java catch multiple exceptions in one catch block?

Yes. Since Java 7, use multi-catch syntax with | between exception types.

catch (IOException | SQLException e) {
    logFailure(e);
}

Can I use commas instead of | in Java multi-catch?

No. Java uses the pipe character (|) to separate exception types.

Why can I not catch Exception | IOException together?

IOException is already a subtype of Exception. Java disallows superclass-and-subclass combinations in one multi-catch because the subclass is redundant.

Can I modify the exception variable in a multi-catch block?

No. The variable is implicitly final. You can read it, log it, and pass it to methods, but cannot assign a new value to it.

Can I catch checked and unchecked exceptions together?

Yes, as long as the checked exceptions can actually be thrown by code in the try block and no listed type is a subclass of another listed type.

Should I always replace repeated catch blocks with multi-catch?

No. Use it only when handling is genuinely identical. Keep separate blocks when recovery, logging, messages, or return values should differ.

Does a multi-catch block tell me which exception occurred?

Yes. The variable contains the actual exception object. For example, e.getClass().getSimpleName() returns its runtime class name.

• try-catch-finally — The foundational structure for handling exceptions and running cleanup code.
• Checked and unchecked exceptions — Explains why some exceptions must be caught or declared while others do not.
• Exception hierarchy — Helps determine when one exception type is a subclass of another.
• throw and throws — Covers creating exceptions and declaring checked exceptions in method signatures.
• Custom exceptions — Lets applications express domain-specific failures such as MappingException.
• Guard clauses — Prevent invalid input early instead of relying on exceptions for normal program flow.
• Try-with-resources — Automatically closes files, streams, and database resources even when exceptions occur.